## Go SDK Changes:

* `PlexApi.LibraryPlaylists.AddPlaylistItems()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Hubs.GetMetadataHubs()`: 
  *  `request.Request.OnlyTransient` **Changed**
  *  `response.MediaContainer.Hub.[].Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.LibraryCollections.MoveCollectionItem()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.LibraryCollections.DeleteCollectionItem()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.LibraryCollections.AddCollectionItems()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Content.GetSonicallySimilar()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Butler.StopTask()`:  `request.Request` **Changed** **Breaking** ⚠️
* `PlexApi.Butler.StartTask()`:  `request.Request` **Changed** **Breaking** ⚠️
* `PlexApi.Content.GetSonicPath()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.DownloadQueue.GetItemDecision()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Hubs.GetAllHubs()`: 
  *  `request.Request.OnlyTransient` **Changed**
  *  `response.MediaContainer.Hub.[].Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Hubs.GetContinueWatching()`:  `response.MediaContainer.Hub.[].Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Hubs.GetPromotedHubs()`:  `response.MediaContainer.Hub.[].Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Content.GetAllLeaves()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Hubs.GetPostplayHubs()`: 
  *  `request.Request.OnlyTransient` **Changed**
  *  `response.MediaContainer.Hub.[].Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Hubs.GetRelatedHubs()`: 
  *  `request.Request.OnlyTransient` **Changed**
  *  `response.MediaContainer.Hub.[].Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Hubs.GetSectionHubs()`: 
  *  `request.Request.OnlyTransient` **Changed**
  *  `response.MediaContainer.Hub.[].Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Content.ListContent()`: 
  *  `request.Request` **Changed**
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Content.GetAlbums()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Search.SearchHubs()`:  `response.MediaContainer.Hub.[].Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Search.VoiceSearchHubs()`: 
  *  `request.Request.Type` **Changed** **Breaking** ⚠️
  *  `response.MediaContainer.Hub.[].Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.GetLibraryItems()`: 
  *  `request.Request.MediaQuery` **Changed**
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.IngestTransientItem()`: 
  *  `request.Request` **Changed**
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.GetLibraryMatches()`: 
  *  `request.Request` **Changed** **Breaking** ⚠️
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Content.GetMetadataItem()`: 
  *  `request.Request` **Changed**
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.GetSections()`:  `response.MediaContainer.Directory.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.AddSection()`: 
  *  `request.Request` **Changed**
  *  `response.MediaContainer.Directory.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.GetTags()`: 
  *  `request.Request.Type` **Changed** **Breaking** ⚠️
* `PlexApi.Content.GetCollectionItems()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.GetAllItemLeaves()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Status.ListSessions()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.PlayQueue.MovePlayQueueItem()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.GetExtras()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.PlayQueue.DeletePlayQueueItem()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.PlayQueue.Unshuffle()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.ListMatches()`: 
  *  `request.Request.Manual` **Changed**
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.ListSonicallySimilar()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.PlayQueue.ResetPlayQueue()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.GetRelatedItems()`:  `response.MediaContainer.Hub.[].Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.ListSimilar()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.PlayQueue.ClearPlayQueue()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.GetItemTree()`:  `response.MediaContainer.MetadataItem.[]` **Changed** **Breaking** ⚠️
* `PlexApi.PlayQueue.AddToPlayQueue()`: 
  *  `request.Request.Next` **Changed**
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.PlayQueue.GetPlayQueue()`: 
  *  `request.Request` **Changed**
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.LibraryPlaylists.MovePlaylistItem()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.GetPerson()`:  `response.MediaContainer.Directory.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.ListPersonMedia()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.LibraryPlaylists.GetPlaylistGeneratorItems()`:  `response.MediaContainer.Metadata` **Changed** **Breaking** ⚠️
* `PlexApi.Library.GetLibraryDetails()`: 
  *  `request.Request.IncludeDetails` **Changed**
  *  `response.MediaContainer.Directory.[]` **Changed** **Breaking** ⚠️
* `PlexApi.LibraryPlaylists.ModifyPlaylistGenerator()`: 
  *  `request.Request.Item` **Changed**
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.Autocomplete()`: 
  *  `request.Request.MediaQuery` **Changed**
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.GetCollections()`: 
  *  `request.Request.MediaQuery` **Changed**
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.GetCommon()`: 
  *  `request.Request.MediaQuery` **Changed**
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.LibraryPlaylists.DeletePlaylistItem()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.LibraryPlaylists.ClearPlaylistItems()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.PlayQueue.Shuffle()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.LibraryPlaylists.CreatePlaylist()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Playlist.GetPlaylistItems()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Playlist.GetPlaylist()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Collections.CreateCollection()`: 
  *  `request.Request.Type` **Changed** **Breaking** ⚠️
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.DvRs.TuneChannel()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.LiveTv.GetSessions()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.LiveTv.GetLiveTvSession()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Playlist.ListPlaylists()`:  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Subscriptions.GetAllSubscriptions()`: 
  *  `request.Request` **Changed**
  *  `response.MediaContainer.MediaSubscription.[].MediaGrabOperation.[].Metadata` **Changed** **Breaking** ⚠️
* `PlexApi.Subscriptions.CreateSubscription()`:  `response.MediaContainer.MediaSubscription.[].MediaGrabOperation.[].Metadata` **Changed** **Breaking** ⚠️
* `PlexApi.Subscriptions.GetScheduledRecordings()`:  `response.MediaContainer.MediaGrabOperation.[].Metadata` **Changed** **Breaking** ⚠️
* `PlexApi.Subscriptions.GetTemplate()`:  `response.MediaContainer.SubscriptionTemplate.[].MediaSubscription.[].MediaGrabOperation.[].Metadata` **Changed** **Breaking** ⚠️
* `PlexApi.Subscriptions.GetSubscription()`: 
  *  `request.Request` **Changed**
  *  `response.MediaContainer.MediaSubscription.[].MediaGrabOperation.[].Metadata` **Changed** **Breaking** ⚠️
* `PlexApi.Subscriptions.EditSubscriptionPreferences()`:  `response.MediaContainer.MediaSubscription.[].MediaGrabOperation.[].Metadata` **Changed** **Breaking** ⚠️
* `PlexApi.Subscriptions.ReorderSubscription()`:  `response.MediaContainer.MediaSubscription.[].MediaGrabOperation.[].Metadata` **Changed** **Breaking** ⚠️
* `PlexApi.Transcoder.MakeDecision()`: 
  *  `request.Request` **Changed**
  *  `response.MediaContainer.Metadata.[]` **Changed** **Breaking** ⚠️
* `PlexApi.Library.RefreshItemsMetadata()`: 
  *  `request.Request.MarkUpdated` **Changed**
* `PlexApi.Authentication.Post-Users-Sign-In-Data()`: **Added**
* `PlexApi.Transcoder.StartTranscodeSession()`:  `request.Request` **Changed**
* `PlexApi.Devices.ModifyDevice()`: 
  *  `request.Request.Enabled` **Changed**
* `PlexApi.Library.GetMediaPart()`: 
  *  `request.Request.Download` **Changed**
* `PlexApi.Library.DetectIntros()`: 
  *  `request.Request.Force` **Changed**
* `PlexApi.Library.RefreshSection()`: 
  *  `request.Request.Force` **Changed**
* `PlexApi.LibraryPlaylists.UploadPlaylist()`: 
  *  `request.Request.Force` **Changed**
* `PlexApi.Library.DeleteMediaItem()`: 
  *  `request.Request.Proxy` **Changed**
* `PlexApi.Authentication.GetTokenDetails()`: **Added**
* `PlexApi.Library.GetFirstCharacters()`: 
  *  `request.Request.MediaQuery` **Changed**
* `PlexApi.Library.UpdateItems()`: 
  *  `request.Request.Field.locked` **Changed**
* `PlexApi.Library.DeleteLibrarySection()`: 
  *  `request.Request.Async` **Changed**
* `PlexApi.Library.SetStreamSelection()`: 
  *  `request.Request.AllParts` **Changed**
* `PlexApi.PlayQueue.CreatePlayQueue()`:  `request.Request` **Changed**
* `PlexApi.Library.GetAugmentationStatus()`: 
  *  `request.Request.Wait` **Changed**
* `PlexApi.Library.DetectVoiceActivity()`:  `request.Request` **Changed**
* `PlexApi.Transcoder.TranscodeImage()`:  `request.Request` **Changed**
* `PlexApi.Transcoder.TranscodeSubtitles()`:  `request.Request` **Changed**
* `PlexApi.Library.AddSubtitles()`:  `request.Request` **Changed**
* `PlexApi.Library.GetStream()`: 
  *  `request.Request.AutoAdjustSubtitle` **Changed**
* `PlexApi.Library.StartBifGeneration()`: 
  *  `request.Request.Force` **Changed**
* `PlexApi.Library.DetectCredits()`:  `request.Request` **Changed**
* `PlexApi.UltraBlur.GetImage()`: 
  *  `request.Request.Noise` **Changed**
* `PlexApi.Library.GenerateThumbs()`: 
  *  `request.Request.Force` **Changed**
* `PlexApi.Updater.ApplyUpdates()`:  `request.Request` **Changed**
* `PlexApi.Updater.CheckUpdates()`: 
  *  `request.Request.Download` **Changed**
* `PlexApi.Library.DeleteMetadataItem()`: 
  *  `request.Request.Proxy` **Changed**
* `PlexApi.Library.OptimizeDatabase()`: 
  *  `request.Request.Async` **Changed**
* `PlexApi.Hubs.UpdateHubVisibility()`:  `request.Request` **Changed**
* `PlexApi.Hubs.CreateCustomHub()`:  `request.Request` **Changed**
* `PlexApi.Library.GetSectionImage()`: 
  *  `request.Request.MediaQuery` **Changed**
* `PlexApi.DownloadQueue.AddDownloadQueueItems()`:  `request.Request` **Changed**
* `PlexApi.Timeline.Report()`:  `request.Request` **Changed**
* `PlexApi.General.GetSourceConnectionInformation()`: 
  *  `request.Request.Refresh` **Changed**
* `PlexApi.Plex.Get-Server-Resources()`: **Added**
* `PlexApi.Users.Get-Users()`: **Added**

.github/workflows/sdk_generation.yaml

@@ -11,18 +11,18 @@ permissions:
         description: Force generation of SDKs
         type: boolean
         default: false
+      set_version:
+        description: optionally set a specific SDK version
+        type: string
   schedule:
     - cron: 0 0 * * *
 jobs:
   generate:
-    uses: speakeasy-api/sdk-generation-action/.github/workflows/sdk-generation.yaml@v14
+    uses: speakeasy-api/sdk-generation-action/.github/workflows/workflow-executor.yaml@v15
     with:
       force: ${{ github.event.inputs.force }}
-      languages: |
-        - go
       mode: direct
-      openapi_docs: |
-        - https://raw.githubusercontent.com/LukeHagar/plex-api-spec/main/plex-media-server-spec-dereferenced.yaml
+      set_version: ${{ github.event.inputs.set_version }}
       speakeasy_version: latest
     secrets:
       github_access_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/sdk_publish.yaml

@@ -0,0 +1,19 @@
+name: Publish
+permissions:
+  checks: write
+  contents: write
+  pull-requests: write
+  statuses: write
+"on":
+  push:
+    branches:
+      - main
+    paths:
+      - RELEASES.md
+      - '*/RELEASES.md'
+jobs:
+  publish:
+    uses: speakeasy-api/sdk-generation-action/.github/workflows/sdk-publish.yaml@v15
+    secrets:
+      github_access_token: ${{ secrets.GITHUB_TOKEN }}
+      speakeasy_api_key: ${{ secrets.SPEAKEASY_API_KEY }}

.gitignore

@@ -1 +1,7 @@
+.env
+.env.local
+.DS_Store
+**/.speakeasy/temp/
+**/.speakeasy/logs/
+.speakeasy/reports
 # .gitignore

.speakeasy/gen.yaml

@@ -0,0 +1,56 @@
+configVersion: 2.0.0
+generation:
+  sdkClassName: Plex-API
+  maintainOpenAPIOrder: true
+  usageSnippets:
+    optionalPropertyRendering: withExample
+    sdkInitStyle: constructor
+  useClassNamesForArrayFields: true
+  fixes:
+    nameResolutionDec2023: true
+    nameResolutionFeb2025: false
+    parameterOrderingFeb2024: true
+    requestResponseComponentNamesFeb2024: true
+    securityFeb2025: false
+    sharedErrorComponentsApr2025: false
+  auth:
+    oAuth2ClientCredentialsEnabled: true
+    oAuth2PasswordEnabled: false
+    hoistGlobalSecurity: true
+  schemas:
+    allOfMergeStrategy: shallowMerge
+  requestBodyFieldName: ""
+  tests:
+    generateTests: true
+    generateNewTests: false
+    skipResponseBodyAssertions: false
+go:
+  version: 0.28.0
+  additionalDependencies: {}
+  allowUnknownFieldsInWeakUnions: false
+  baseErrorName: PlexAPIError
+  clientServerStatusCodesAsErrors: true
+  defaultErrorName: SDKError
+  flattenGlobalSecurity: true
+  imports:
+    option: openapi
+    paths:
+      callbacks: models/callbacks
+      errors: models/sdkerrors
+      operations: models/operations
+      shared: models/components
+      webhooks: models/webhooks
+  includeEmptyObjects: false
+  inferUnionDiscriminators: false
+  inputModelSuffix: input
+  maxMethodParams: 4
+  methodArguments: require-security-and-request
+  modulePath: ""
+  multipartArrayFormat: legacy
+  nullableOptionalWrapper: false
+  outputModelSuffix: output
+  packageName: github.com/LukeHagar/plexgo
+  respectRequiredFields: false
+  responseFormat: envelope
+  sdkPackageName: ""
+  unionStrategy: left-to-right

.speakeasy/workflow.lock

@@ -0,0 +1,44 @@
+speakeasyVersion: 1.665.0
+sources:
+    my-source:
+        sourceNamespace: my-source
+        sourceRevisionDigest: sha256:92a2a2049bfbf67bea601a6b1b77d274e83a2d3b6968a0bc02dc290b21c7689d
+        sourceBlobDigest: sha256:f7e2709f52370dff16c1851a7a4e44a89f2e978e9cae335bffc10625950b3bd9
+        tags:
+            - latest
+            - main
+    plexapi:
+        sourceNamespace: plexapi
+        sourceRevisionDigest: sha256:ace004a3b232e8ab9ca3d89f2da8e40470236e6d997073a16c3f8872d67a7383
+        sourceBlobDigest: sha256:993bfb796a3833b0a3b813ad12469ca34db94f23c2d15ae988a26b4d1ed80fbe
+        tags:
+            - latest
+            - speakeasy-sdk-regen-1764548025
+            - 1.1.1
+targets:
+    plexgo:
+        source: plexapi
+        sourceNamespace: plexapi
+        sourceRevisionDigest: sha256:ace004a3b232e8ab9ca3d89f2da8e40470236e6d997073a16c3f8872d67a7383
+        sourceBlobDigest: sha256:993bfb796a3833b0a3b813ad12469ca34db94f23c2d15ae988a26b4d1ed80fbe
+        codeSamplesNamespace: code-samples-go-plexgo
+        codeSamplesRevisionDigest: sha256:d79ec0f33d0e234749ae5970ad2528646cdd6ec28c7e8d7e29cc39b857f58cde
+workflow:
+    workflowVersion: 1.0.0
+    speakeasyVersion: latest
+    sources:
+        plexapi:
+            inputs:
+                - location: https://raw.githubusercontent.com/LukeHagar/plex-api-spec/refs/heads/main/plex-api-spec.yaml
+            registry:
+                location: registry.speakeasyapi.dev/plexapi/plexapi/plexapi
+    targets:
+        plexgo:
+            target: go
+            source: plexapi
+            codeSamples:
+                output: codeSamples.yaml
+                registry:
+                    location: registry.speakeasyapi.dev/plexapi/plexapi/code-samples-go-plexgo
+                labelOverride:
+                    fixedValue: PlexGO

.speakeasy/workflow.yaml

@@ -0,0 +1,18 @@
+workflowVersion: 1.0.0
+speakeasyVersion: latest
+sources:
+    plexapi:
+        inputs:
+            - location: https://raw.githubusercontent.com/LukeHagar/plex-api-spec/refs/heads/main/plex-api-spec.yaml
+        registry:
+            location: registry.speakeasyapi.dev/plexapi/plexapi/plexapi
+targets:
+    plexgo:
+        target: go
+        source: plexapi
+        codeSamples:
+            output: codeSamples.yaml
+            registry:
+                location: registry.speakeasyapi.dev/plexapi/plexapi/code-samples-go-plexgo
+            labelOverride:
+                fixedValue: PlexGO

CONTRIBUTING.md

@@ -0,0 +1,26 @@
+# Contributing to This Repository
+
+Thank you for your interest in contributing to this repository. Please note that this repository contains generated code. As such, we do not accept direct changes or pull requests. Instead, we encourage you to follow the guidelines below to report issues and suggest improvements.
+
+## How to Report Issues
+
+If you encounter any bugs or have suggestions for improvements, please open an issue on GitHub. When reporting an issue, please provide as much detail as possible to help us reproduce the problem. This includes:
+
+- A clear and descriptive title
+- Steps to reproduce the issue
+- Expected and actual behavior
+- Any relevant logs, screenshots, or error messages
+- Information about your environment (e.g., operating system, software versions)
+    - For example can be collected using the `npx envinfo` command from your terminal if you have Node.js installed
+
+## Issue Triage and Upstream Fixes
+
+We will review and triage issues as quickly as possible. Our goal is to address bugs and incorporate improvements in the upstream source code. Fixes will be included in the next generation of the generated code.
+
+## Contact
+
+If you have any questions or need further assistance, please feel free to reach out by opening an issue.
+
+Thank you for your understanding and cooperation!
+
+The Maintainers

USAGE.md

@@ -6,21 +6,63 @@ import (
 	"context"
 	"github.com/LukeHagar/plexgo"
 	"github.com/LukeHagar/plexgo/models/components"
+	"github.com/LukeHagar/plexgo/models/operations"
 	"log"
 )
 
 func main() {
+	ctx := context.Background()
+
 	s := plexgo.New(
+		plexgo.WithAccepts(components.AcceptsApplicationXML),
+		plexgo.WithClientIdentifier("abc123"),
+		plexgo.WithProduct("Plex for Roku"),
+		plexgo.WithVersion("2.4.1"),
+		plexgo.WithPlatform("Roku"),
+		plexgo.WithPlatformVersion("4.3 build 1057"),
+		plexgo.WithDevice("Roku 3"),
+		plexgo.WithModel("4200X"),
+		plexgo.WithDeviceVendor("Roku"),
+		plexgo.WithDeviceName("Living Room TV"),
+		plexgo.WithMarketplace("googlePlay"),
 		plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
-		plexgo.WithXPlexClientIdentifier("<value>"),
 	)
 
-	ctx := context.Background()
-	res, err := s.Server.GetServerCapabilities(ctx)
+	res, err := s.Transcoder.StartTranscodeSession(ctx, operations.StartTranscodeSessionRequest{
+		TranscodeType:             components.TranscodeTypeMusic,
+		Extension:                 operations.ExtensionMpd,
+		AdvancedSubtitles:         components.AdvancedSubtitlesBurn.ToPointer(),
+		AudioBoost:                plexgo.Pointer[int64](50),
+		AudioChannelCount:         plexgo.Pointer[int64](5),
+		AutoAdjustQuality:         components.BoolIntTrue.ToPointer(),
+		AutoAdjustSubtitle:        components.BoolIntTrue.ToPointer(),
+		DirectPlay:                components.BoolIntTrue.ToPointer(),
+		DirectStream:              components.BoolIntTrue.ToPointer(),
+		DirectStreamAudio:         components.BoolIntTrue.ToPointer(),
+		DisableResolutionRotation: components.BoolIntTrue.ToPointer(),
+		HasMDE:                    components.BoolIntTrue.ToPointer(),
+		Location:                  operations.StartTranscodeSessionQueryParamLocationWan.ToPointer(),
+		MediaBufferSize:           plexgo.Pointer[int64](102400),
+		MediaIndex:                plexgo.Pointer[int64](0),
+		MusicBitrate:              plexgo.Pointer[int64](5000),
+		Offset:                    plexgo.Pointer[float64](90.5),
+		PartIndex:                 plexgo.Pointer[int64](0),
+		Path:                      plexgo.Pointer("/library/metadata/151671"),
+		PeakBitrate:               plexgo.Pointer[int64](12000),
+		PhotoResolution:           plexgo.Pointer("1080x1080"),
+		Protocol:                  operations.StartTranscodeSessionQueryParamProtocolDash.ToPointer(),
+		SecondsPerSegment:         plexgo.Pointer[int64](5),
+		SubtitleSize:              plexgo.Pointer[int64](50),
+		VideoBitrate:              plexgo.Pointer[int64](12000),
+		VideoQuality:              plexgo.Pointer[int64](50),
+		VideoResolution:           plexgo.Pointer("1080x1080"),
+		XPlexClientProfileExtra:   plexgo.Pointer("add-limitation(scope=videoCodec&scopeName=*&type=upperBound&name=video.frameRate&value=60&replace=true)+append-transcode-target-codec(type=videoProfile&context=streaming&videoCodec=h264%2Chevc&audioCodec=aac&protocol=dash)"),
+		XPlexClientProfileName:    plexgo.Pointer("generic"),
+	})
 	if err != nil {
 		log.Fatal(err)
 	}
-	if res.Object != nil {
+	if res.ResponseStream != nil {
 		// handle response
 	}
 }

activities.go

@@ -1,4 +1,4 @@
-// Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+// Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 
 package plexgo
 
@@ -6,48 +6,82 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"github.com/LukeHagar/plexgo/internal/config"
 	"github.com/LukeHagar/plexgo/internal/hooks"
 	"github.com/LukeHagar/plexgo/internal/utils"
 	"github.com/LukeHagar/plexgo/models/operations"
 	"github.com/LukeHagar/plexgo/models/sdkerrors"
-	"io"
+	"github.com/LukeHagar/plexgo/retry"
 	"net/http"
 	"net/url"
 )
 
-// Activities are awesome. They provide a way to monitor and control asynchronous operations on the server. In order to receive real-time updates for activities, a client would normally subscribe via either EventSource or Websocket endpoints.
+// Activities provide a way to monitor and control asynchronous operations on the server. In order to receive real-time updates for activities, a client would normally subscribe via either EventSource or Websocket endpoints.
+//
 // Activities are associated with HTTP replies via a special `X-Plex-Activity` header which contains the UUID of the activity.
-// Activities are optional cancellable. If cancellable, they may be cancelled via the `DELETE` endpoint. Other details:
-// - They can contain a `progress` (from 0 to 100) marking the percent completion of the activity.
-// - They must contain an `type` which is used by clients to distinguish the specific activity.
-// - They may contain a `Context` object with attributes which associate the activity with various specific entities (items, libraries, etc.)
-// - The may contain a `Response` object which attributes which represent the result of the asynchronous operation.
+//
+// Activities are optional cancellable. If cancellable, they may be cancelled via the `DELETE` endpoint.
 type Activities struct {
-	sdkConfiguration sdkConfiguration
+	rootSDK          *PlexAPI
+	sdkConfiguration config.SDKConfiguration
+	hooks            *hooks.Hooks
 }
 
-func newActivities(sdkConfig sdkConfiguration) *Activities {
+func newActivities(rootSDK *PlexAPI, sdkConfig config.SDKConfiguration, hooks *hooks.Hooks) *Activities {
 	return &Activities{
+		rootSDK:          rootSDK,
 		sdkConfiguration: sdkConfig,
+		hooks:            hooks,
 	}
 }
 
-// GetServerActivities - Get Server Activities
-// Get Server Activities
-func (s *Activities) GetServerActivities(ctx context.Context) (*operations.GetServerActivitiesResponse, error) {
-	hookCtx := hooks.HookContext{
-		Context:        ctx,
-		OperationID:    "getServerActivities",
-		OAuth2Scopes:   []string{},
-		SecuritySource: s.sdkConfiguration.Security,
+// ListActivities - Get all activities
+// List all activities on the server.  Admins can see all activities but other users can only see their own
+func (s *Activities) ListActivities(ctx context.Context, opts ...operations.Option) (*operations.ListActivitiesResponse, error) {
+	o := operations.Options{}
+	supportedOptions := []string{
+		operations.SupportedOptionRetries,
+		operations.SupportedOptionTimeout,
 	}
 
-	baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
+	for _, opt := range opts {
+		if err := opt(&o, supportedOptions...); err != nil {
+			return nil, fmt.Errorf("error applying option: %w", err)
+		}
+	}
+
+	var baseURL string
+	if o.ServerURL == nil {
+		baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
+	} else {
+		baseURL = *o.ServerURL
+	}
 	opURL, err := url.JoinPath(baseURL, "/activities")
 	if err != nil {
 		return nil, fmt.Errorf("error generating URL: %w", err)
 	}
 
+	hookCtx := hooks.HookContext{
+		SDK:              s.rootSDK,
+		SDKConfiguration: s.sdkConfiguration,
+		BaseURL:          baseURL,
+		Context:          ctx,
+		OperationID:      "listActivities",
+		OAuth2Scopes:     nil,
+		SecuritySource:   s.sdkConfiguration.Security,
+	}
+
+	timeout := o.Timeout
+	if timeout == nil {
+		timeout = s.sdkConfiguration.Timeout
+	}
+
+	if timeout != nil {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, *timeout)
+		defer cancel()
+	}
+
 	req, err := http.NewRequestWithContext(ctx, "GET", opURL, nil)
 	if err != nil {
 		return nil, fmt.Errorf("error creating request: %w", err)
@@ -59,11 +93,49 @@ func (s *Activities) GetServerActivities(ctx context.Context) (*operations.GetSe
 		return nil, err
 	}
 
-	req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
+	for k, v := range o.SetHeaders {
+		req.Header.Set(k, v)
+	}
+
+	globalRetryConfig := s.sdkConfiguration.RetryConfig
+	retryConfig := o.Retries
+	if retryConfig == nil {
+		if globalRetryConfig != nil {
+			retryConfig = globalRetryConfig
+		}
+	}
+
+	var httpRes *http.Response
+	if retryConfig != nil {
+		httpRes, err = utils.Retry(ctx, utils.Retries{
+			Config: retryConfig,
+			StatusCodes: []string{
+				"429",
+				"500",
+				"502",
+				"503",
+				"504",
+			},
+		}, func() (*http.Response, error) {
+			if req.Body != nil && req.Body != http.NoBody && req.GetBody != nil {
+				copyBody, err := req.GetBody()
+
 				if err != nil {
 					return nil, err
 				}
 
+				req.Body = copyBody
+			}
+
+			req, err = s.hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
+			if err != nil {
+				if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
+					return nil, err
+				}
+
+				return nil, retry.Permanent(err)
+			}
+
 			httpRes, err := s.sdkConfiguration.Client.Do(req)
 			if err != nil || httpRes == nil {
 				if err != nil {
@@ -72,108 +144,219 @@ func (s *Activities) GetServerActivities(ctx context.Context) (*operations.GetSe
 					err = fmt.Errorf("error sending request: no response")
 				}
 
-		_, err = s.sdkConfiguration.Hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+				_, err = s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+			}
+			return httpRes, err
+		})
+
+		if err != nil {
 			return nil, err
-	} else if utils.MatchStatusCodes([]string{"400", "401", "4XX", "5XX"}, httpRes.StatusCode) {
-		httpRes, err = s.sdkConfiguration.Hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, httpRes, nil)
+		} else {
+			httpRes, err = s.hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
 			if err != nil {
 				return nil, err
 			}
+		}
 	} else {
-		httpRes, err = s.sdkConfiguration.Hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
+		req, err = s.hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
 		if err != nil {
 			return nil, err
 		}
+
+		httpRes, err = s.sdkConfiguration.Client.Do(req)
+		if err != nil || httpRes == nil {
+			if err != nil {
+				err = fmt.Errorf("error sending request: %w", err)
+			} else {
+				err = fmt.Errorf("error sending request: no response")
+			}
+
+			_, err = s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+			return nil, err
+		} else if utils.MatchStatusCodes([]string{"4XX", "5XX"}, httpRes.StatusCode) {
+			_httpRes, err := s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, httpRes, nil)
+			if err != nil {
+				return nil, err
+			} else if _httpRes != nil {
+				httpRes = _httpRes
+			}
+		} else {
+			httpRes, err = s.hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
+			if err != nil {
+				return nil, err
+			}
+		}
 	}
 
-	res := &operations.GetServerActivitiesResponse{
+	res := &operations.ListActivitiesResponse{
 		StatusCode:  httpRes.StatusCode,
 		ContentType: httpRes.Header.Get("Content-Type"),
 		RawResponse: httpRes,
 	}
 
-	rawBody, err := io.ReadAll(httpRes.Body)
-	if err != nil {
-		return nil, fmt.Errorf("error reading response body: %w", err)
-	}
-	httpRes.Body.Close()
-	httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
-
 	switch {
 	case httpRes.StatusCode == 200:
 		switch {
 		case utils.MatchContentType(httpRes.Header.Get("Content-Type"), `application/json`):
-			var out operations.GetServerActivitiesResponseBody
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
+
+			var out operations.ListActivitiesResponseBody
 			if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
 				return nil, err
 			}
 
 			res.Object = &out
 		default:
-			return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", httpRes.Header.Get("Content-Type")), httpRes.StatusCode, string(rawBody), httpRes)
-		}
-	case httpRes.StatusCode == 400:
-		fallthrough
-	case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
-		fallthrough
-	case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
-		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
-	case httpRes.StatusCode == 401:
-		switch {
-		case utils.MatchContentType(httpRes.Header.Get("Content-Type"), `application/json`):
-			var out sdkerrors.GetServerActivitiesResponseBody
-			if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
 				return nil, err
 			}
-
-			out.RawResponse = httpRes
-			return nil, &out
-		default:
 			return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", httpRes.Header.Get("Content-Type")), httpRes.StatusCode, string(rawBody), httpRes)
 		}
+	case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
+		}
+		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
+	case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
+		}
+		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
 	default:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
+		}
 		return nil, sdkerrors.NewSDKError("unknown status code returned", httpRes.StatusCode, string(rawBody), httpRes)
 	}
 
 	return res, nil
+
+}
+
+// CancelActivity - Cancel a running activity
+// Cancel a running activity.  Admins can cancel all activities but other users can only cancel their own
+func (s *Activities) CancelActivity(ctx context.Context, request operations.CancelActivityRequest, opts ...operations.Option) (*operations.CancelActivityResponse, error) {
+	globals := operations.CancelActivityGlobals{
+		Accepts:          s.sdkConfiguration.Globals.Accepts,
+		ClientIdentifier: s.sdkConfiguration.Globals.ClientIdentifier,
+		Product:          s.sdkConfiguration.Globals.Product,
+		Version:          s.sdkConfiguration.Globals.Version,
+		Platform:         s.sdkConfiguration.Globals.Platform,
+		PlatformVersion:  s.sdkConfiguration.Globals.PlatformVersion,
+		Device:           s.sdkConfiguration.Globals.Device,
+		Model:            s.sdkConfiguration.Globals.Model,
+		DeviceVendor:     s.sdkConfiguration.Globals.DeviceVendor,
+		DeviceName:       s.sdkConfiguration.Globals.DeviceName,
+		Marketplace:      s.sdkConfiguration.Globals.Marketplace,
+	}
+
+	o := operations.Options{}
+	supportedOptions := []string{
+		operations.SupportedOptionRetries,
+		operations.SupportedOptionTimeout,
+	}
+
+	for _, opt := range opts {
+		if err := opt(&o, supportedOptions...); err != nil {
+			return nil, fmt.Errorf("error applying option: %w", err)
+		}
+	}
+
+	var baseURL string
+	if o.ServerURL == nil {
+		baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
+	} else {
+		baseURL = *o.ServerURL
+	}
+	opURL, err := utils.GenerateURL(ctx, baseURL, "/activities/{activityId}", request, globals)
+	if err != nil {
+		return nil, fmt.Errorf("error generating URL: %w", err)
 	}
 
-// CancelServerActivities - Cancel Server Activities
-// Cancel Server Activities
-func (s *Activities) CancelServerActivities(ctx context.Context, activityUUID string) (*operations.CancelServerActivitiesResponse, error) {
 	hookCtx := hooks.HookContext{
+		SDK:              s.rootSDK,
+		SDKConfiguration: s.sdkConfiguration,
+		BaseURL:          baseURL,
 		Context:          ctx,
-		OperationID:    "cancelServerActivities",
-		OAuth2Scopes:   []string{},
+		OperationID:      "cancelActivity",
+		OAuth2Scopes:     nil,
 		SecuritySource:   s.sdkConfiguration.Security,
 	}
 
-	request := operations.CancelServerActivitiesRequest{
-		ActivityUUID: activityUUID,
+	timeout := o.Timeout
+	if timeout == nil {
+		timeout = s.sdkConfiguration.Timeout
 	}
 
-	baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
-	opURL, err := utils.GenerateURL(ctx, baseURL, "/activities/{activityUUID}", request, nil)
-	if err != nil {
-		return nil, fmt.Errorf("error generating URL: %w", err)
+	if timeout != nil {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, *timeout)
+		defer cancel()
 	}
 
 	req, err := http.NewRequestWithContext(ctx, "DELETE", opURL, nil)
 	if err != nil {
 		return nil, fmt.Errorf("error creating request: %w", err)
 	}
-	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Accept", "*/*")
 	req.Header.Set("User-Agent", s.sdkConfiguration.UserAgent)
 
+	utils.PopulateHeaders(ctx, req, request, globals)
+
 	if err := utils.PopulateSecurity(ctx, req, s.sdkConfiguration.Security); err != nil {
 		return nil, err
 	}
 
-	req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
+	for k, v := range o.SetHeaders {
+		req.Header.Set(k, v)
+	}
+
+	globalRetryConfig := s.sdkConfiguration.RetryConfig
+	retryConfig := o.Retries
+	if retryConfig == nil {
+		if globalRetryConfig != nil {
+			retryConfig = globalRetryConfig
+		}
+	}
+
+	var httpRes *http.Response
+	if retryConfig != nil {
+		httpRes, err = utils.Retry(ctx, utils.Retries{
+			Config: retryConfig,
+			StatusCodes: []string{
+				"429",
+				"500",
+				"502",
+				"503",
+				"504",
+			},
+		}, func() (*http.Response, error) {
+			if req.Body != nil && req.Body != http.NoBody && req.GetBody != nil {
+				copyBody, err := req.GetBody()
+
 				if err != nil {
 					return nil, err
 				}
 
+				req.Body = copyBody
+			}
+
+			req, err = s.hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
+			if err != nil {
+				if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
+					return nil, err
+				}
+
+				return nil, retry.Permanent(err)
+			}
+
 			httpRes, err := s.sdkConfiguration.Client.Do(req)
 			if err != nil || httpRes == nil {
 				if err != nil {
@@ -182,57 +365,82 @@ func (s *Activities) CancelServerActivities(ctx context.Context, activityUUID st
 					err = fmt.Errorf("error sending request: no response")
 				}
 
-		_, err = s.sdkConfiguration.Hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+				_, err = s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+			}
+			return httpRes, err
+		})
+
+		if err != nil {
 			return nil, err
-	} else if utils.MatchStatusCodes([]string{"400", "401", "4XX", "5XX"}, httpRes.StatusCode) {
-		httpRes, err = s.sdkConfiguration.Hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, httpRes, nil)
+		} else {
+			httpRes, err = s.hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
 			if err != nil {
 				return nil, err
 			}
+		}
 	} else {
-		httpRes, err = s.sdkConfiguration.Hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
+		req, err = s.hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
 		if err != nil {
 			return nil, err
 		}
+
+		httpRes, err = s.sdkConfiguration.Client.Do(req)
+		if err != nil || httpRes == nil {
+			if err != nil {
+				err = fmt.Errorf("error sending request: %w", err)
+			} else {
+				err = fmt.Errorf("error sending request: no response")
+			}
+
+			_, err = s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+			return nil, err
+		} else if utils.MatchStatusCodes([]string{"400", "404", "4XX", "5XX"}, httpRes.StatusCode) {
+			_httpRes, err := s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, httpRes, nil)
+			if err != nil {
+				return nil, err
+			} else if _httpRes != nil {
+				httpRes = _httpRes
+			}
+		} else {
+			httpRes, err = s.hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
+			if err != nil {
+				return nil, err
+			}
+		}
 	}
 
-	res := &operations.CancelServerActivitiesResponse{
+	res := &operations.CancelActivityResponse{
 		StatusCode:  httpRes.StatusCode,
 		ContentType: httpRes.Header.Get("Content-Type"),
 		RawResponse: httpRes,
 	}
 
-	rawBody, err := io.ReadAll(httpRes.Body)
-	if err != nil {
-		return nil, fmt.Errorf("error reading response body: %w", err)
-	}
-	httpRes.Body.Close()
-	httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
-
 	switch {
 	case httpRes.StatusCode == 200:
 	case httpRes.StatusCode == 400:
 		fallthrough
-	case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
+	case httpRes.StatusCode == 404:
 		fallthrough
-	case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
-		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
-	case httpRes.StatusCode == 401:
-		switch {
-		case utils.MatchContentType(httpRes.Header.Get("Content-Type"), `application/json`):
-			var out sdkerrors.CancelServerActivitiesResponseBody
-			if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
+	case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
 			return nil, err
 		}
-
-			out.RawResponse = httpRes
-			return nil, &out
-		default:
-			return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", httpRes.Header.Get("Content-Type")), httpRes.StatusCode, string(rawBody), httpRes)
+		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
+	case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
 		}
+		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
 	default:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
+		}
 		return nil, sdkerrors.NewSDKError("unknown status code returned", httpRes.StatusCode, string(rawBody), httpRes)
 	}
 
 	return res, nil
+
 }

authentication.go

@@ -1,4 +1,4 @@
-// Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+// Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 
 package plexgo
 
@@ -6,45 +6,89 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"github.com/LukeHagar/plexgo/internal/config"
 	"github.com/LukeHagar/plexgo/internal/hooks"
 	"github.com/LukeHagar/plexgo/internal/utils"
+	"github.com/LukeHagar/plexgo/models/components"
 	"github.com/LukeHagar/plexgo/models/operations"
 	"github.com/LukeHagar/plexgo/models/sdkerrors"
-	"io"
+	"github.com/LukeHagar/plexgo/retry"
 	"net/http"
 	"net/url"
 )
 
-// Authentication - API Calls regarding authentication for Plex Media Server
 type Authentication struct {
-	sdkConfiguration sdkConfiguration
+	rootSDK          *PlexAPI
+	sdkConfiguration config.SDKConfiguration
+	hooks            *hooks.Hooks
 }
 
-func newAuthentication(sdkConfig sdkConfiguration) *Authentication {
+func newAuthentication(rootSDK *PlexAPI, sdkConfig config.SDKConfiguration, hooks *hooks.Hooks) *Authentication {
 	return &Authentication{
+		rootSDK:          rootSDK,
 		sdkConfiguration: sdkConfig,
+		hooks:            hooks,
 	}
 }
 
-// GetTransientToken - Get a Transient Token.
-// This endpoint provides the caller with a temporary token with the same access level as the caller's token. These tokens are valid for up to 48 hours and are destroyed if the server instance is restarted.
-func (s *Authentication) GetTransientToken(ctx context.Context, type_ operations.GetTransientTokenQueryParamType, scope operations.Scope) (*operations.GetTransientTokenResponse, error) {
+// GetTokenDetails - Get Token Details
+// Get the User data from the provided X-Plex-Token
+func (s *Authentication) GetTokenDetails(ctx context.Context, request operations.GetTokenDetailsRequest, opts ...operations.Option) (*operations.GetTokenDetailsResponse, error) {
+	globals := operations.GetTokenDetailsGlobals{
+		Accepts:          s.sdkConfiguration.Globals.Accepts,
+		ClientIdentifier: s.sdkConfiguration.Globals.ClientIdentifier,
+		Product:          s.sdkConfiguration.Globals.Product,
+		Version:          s.sdkConfiguration.Globals.Version,
+		Platform:         s.sdkConfiguration.Globals.Platform,
+		PlatformVersion:  s.sdkConfiguration.Globals.PlatformVersion,
+		Device:           s.sdkConfiguration.Globals.Device,
+		Model:            s.sdkConfiguration.Globals.Model,
+		DeviceVendor:     s.sdkConfiguration.Globals.DeviceVendor,
+		DeviceName:       s.sdkConfiguration.Globals.DeviceName,
+		Marketplace:      s.sdkConfiguration.Globals.Marketplace,
+	}
+
+	o := operations.Options{}
+	supportedOptions := []string{
+		operations.SupportedOptionRetries,
+		operations.SupportedOptionTimeout,
+	}
+
+	for _, opt := range opts {
+		if err := opt(&o, supportedOptions...); err != nil {
+			return nil, fmt.Errorf("error applying option: %w", err)
+		}
+	}
+
+	baseURL := utils.ReplaceParameters(operations.GetTokenDetailsServerList[0], map[string]string{})
+	if o.ServerURL != nil {
+		baseURL = *o.ServerURL
+	}
+
+	opURL, err := url.JoinPath(baseURL, "/user")
+	if err != nil {
+		return nil, fmt.Errorf("error generating URL: %w", err)
+	}
+
 	hookCtx := hooks.HookContext{
+		SDK:              s.rootSDK,
+		SDKConfiguration: s.sdkConfiguration,
+		BaseURL:          baseURL,
 		Context:          ctx,
-		OperationID:    "getTransientToken",
-		OAuth2Scopes:   []string{},
+		OperationID:      "getTokenDetails",
+		OAuth2Scopes:     nil,
 		SecuritySource:   s.sdkConfiguration.Security,
 	}
 
-	request := operations.GetTransientTokenRequest{
-		Type:  type_,
-		Scope: scope,
+	timeout := o.Timeout
+	if timeout == nil {
+		timeout = s.sdkConfiguration.Timeout
 	}
 
-	baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
-	opURL, err := url.JoinPath(baseURL, "/security/token")
-	if err != nil {
-		return nil, fmt.Errorf("error generating URL: %w", err)
+	if timeout != nil {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, *timeout)
+		defer cancel()
 	}
 
 	req, err := http.NewRequestWithContext(ctx, "GET", opURL, nil)
@@ -54,19 +98,55 @@ func (s *Authentication) GetTransientToken(ctx context.Context, type_ operations
 	req.Header.Set("Accept", "application/json")
 	req.Header.Set("User-Agent", s.sdkConfiguration.UserAgent)
 
-	if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
-		return nil, fmt.Errorf("error populating query params: %w", err)
-	}
+	utils.PopulateHeaders(ctx, req, request, globals)
 
 	if err := utils.PopulateSecurity(ctx, req, s.sdkConfiguration.Security); err != nil {
 		return nil, err
 	}
 
-	req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
+	for k, v := range o.SetHeaders {
+		req.Header.Set(k, v)
+	}
+
+	globalRetryConfig := s.sdkConfiguration.RetryConfig
+	retryConfig := o.Retries
+	if retryConfig == nil {
+		if globalRetryConfig != nil {
+			retryConfig = globalRetryConfig
+		}
+	}
+
+	var httpRes *http.Response
+	if retryConfig != nil {
+		httpRes, err = utils.Retry(ctx, utils.Retries{
+			Config: retryConfig,
+			StatusCodes: []string{
+				"429",
+				"500",
+				"502",
+				"503",
+				"504",
+			},
+		}, func() (*http.Response, error) {
+			if req.Body != nil && req.Body != http.NoBody && req.GetBody != nil {
+				copyBody, err := req.GetBody()
+
 				if err != nil {
 					return nil, err
 				}
 
+				req.Body = copyBody
+			}
+
+			req, err = s.hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
+			if err != nil {
+				if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
+					return nil, err
+				}
+
+				return nil, retry.Permanent(err)
+			}
+
 			httpRes, err := s.sdkConfiguration.Client.Do(req)
 			if err != nil || httpRes == nil {
 				if err != nil {
@@ -75,45 +155,87 @@ func (s *Authentication) GetTransientToken(ctx context.Context, type_ operations
 					err = fmt.Errorf("error sending request: no response")
 				}
 
-		_, err = s.sdkConfiguration.Hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+				_, err = s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+			}
+			return httpRes, err
+		})
+
+		if err != nil {
 			return nil, err
-	} else if utils.MatchStatusCodes([]string{"400", "401", "4XX", "5XX"}, httpRes.StatusCode) {
-		httpRes, err = s.sdkConfiguration.Hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, httpRes, nil)
+		} else {
+			httpRes, err = s.hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
 			if err != nil {
 				return nil, err
 			}
+		}
 	} else {
-		httpRes, err = s.sdkConfiguration.Hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
+		req, err = s.hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
 		if err != nil {
 			return nil, err
 		}
+
+		httpRes, err = s.sdkConfiguration.Client.Do(req)
+		if err != nil || httpRes == nil {
+			if err != nil {
+				err = fmt.Errorf("error sending request: %w", err)
+			} else {
+				err = fmt.Errorf("error sending request: no response")
+			}
+
+			_, err = s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+			return nil, err
+		} else if utils.MatchStatusCodes([]string{"400", "401", "4XX", "5XX"}, httpRes.StatusCode) {
+			_httpRes, err := s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, httpRes, nil)
+			if err != nil {
+				return nil, err
+			} else if _httpRes != nil {
+				httpRes = _httpRes
+			}
+		} else {
+			httpRes, err = s.hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
+			if err != nil {
+				return nil, err
+			}
+		}
 	}
 
-	res := &operations.GetTransientTokenResponse{
+	res := &operations.GetTokenDetailsResponse{
 		StatusCode:  httpRes.StatusCode,
 		ContentType: httpRes.Header.Get("Content-Type"),
 		RawResponse: httpRes,
 	}
 
-	rawBody, err := io.ReadAll(httpRes.Body)
-	if err != nil {
-		return nil, fmt.Errorf("error reading response body: %w", err)
-	}
-	httpRes.Body.Close()
-	httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
-
 	switch {
 	case httpRes.StatusCode == 200:
-	case httpRes.StatusCode == 400:
-		fallthrough
-	case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
-		fallthrough
-	case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
-		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
-	case httpRes.StatusCode == 401:
 		switch {
 		case utils.MatchContentType(httpRes.Header.Get("Content-Type"), `application/json`):
-			var out sdkerrors.GetTransientTokenResponseBody
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
+
+			var out components.UserPlexAccount
+			if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
+				return nil, err
+			}
+
+			res.UserPlexAccount = &out
+		default:
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
+			return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", httpRes.Header.Get("Content-Type")), httpRes.StatusCode, string(rawBody), httpRes)
+		}
+	case httpRes.StatusCode == 400:
+		switch {
+		case utils.MatchContentType(httpRes.Header.Get("Content-Type"), `application/json`):
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
+
+			var out sdkerrors.GetTokenDetailsBadRequest
 			if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
 				return nil, err
 			}
@@ -121,56 +243,177 @@ func (s *Authentication) GetTransientToken(ctx context.Context, type_ operations
 			out.RawResponse = httpRes
 			return nil, &out
 		default:
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
 			return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", httpRes.Header.Get("Content-Type")), httpRes.StatusCode, string(rawBody), httpRes)
 		}
+	case httpRes.StatusCode == 401:
+		switch {
+		case utils.MatchContentType(httpRes.Header.Get("Content-Type"), `application/json`):
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
+
+			var out sdkerrors.GetTokenDetailsUnauthorized
+			if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
+				return nil, err
+			}
+
+			out.RawResponse = httpRes
+			return nil, &out
 		default:
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
+			return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", httpRes.Header.Get("Content-Type")), httpRes.StatusCode, string(rawBody), httpRes)
+		}
+	case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
+		}
+		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
+	case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
+		}
+		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
+	default:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
+		}
 		return nil, sdkerrors.NewSDKError("unknown status code returned", httpRes.StatusCode, string(rawBody), httpRes)
 	}
 
 	return res, nil
+
 }
 
-// GetSourceConnectionInformation - Get Source Connection Information
-// If a caller requires connection details and a transient token for a source that is known to the server, for example a cloud media provider or shared PMS, then this endpoint can be called. This endpoint is only accessible with either an admin token or a valid transient token generated from an admin token.
-// Note: requires Plex Media Server >= 1.15.4.
-func (s *Authentication) GetSourceConnectionInformation(ctx context.Context, source string) (*operations.GetSourceConnectionInformationResponse, error) {
-	hookCtx := hooks.HookContext{
-		Context:        ctx,
-		OperationID:    "getSourceConnectionInformation",
-		OAuth2Scopes:   []string{},
-		SecuritySource: s.sdkConfiguration.Security,
+// PostUsersSignInData - Get User Sign In Data
+// Sign in user with username and password and return user data with Plex authentication token
+func (s *Authentication) PostUsersSignInData(ctx context.Context, request operations.PostUsersSignInDataRequest, opts ...operations.Option) (*operations.PostUsersSignInDataResponse, error) {
+	globals := operations.PostUsersSignInDataGlobals{
+		Accepts:          s.sdkConfiguration.Globals.Accepts,
+		ClientIdentifier: s.sdkConfiguration.Globals.ClientIdentifier,
+		Product:          s.sdkConfiguration.Globals.Product,
+		Version:          s.sdkConfiguration.Globals.Version,
+		Platform:         s.sdkConfiguration.Globals.Platform,
+		PlatformVersion:  s.sdkConfiguration.Globals.PlatformVersion,
+		Device:           s.sdkConfiguration.Globals.Device,
+		Model:            s.sdkConfiguration.Globals.Model,
+		DeviceVendor:     s.sdkConfiguration.Globals.DeviceVendor,
+		DeviceName:       s.sdkConfiguration.Globals.DeviceName,
+		Marketplace:      s.sdkConfiguration.Globals.Marketplace,
 	}
 
-	request := operations.GetSourceConnectionInformationRequest{
-		Source: source,
+	o := operations.Options{}
+	supportedOptions := []string{
+		operations.SupportedOptionRetries,
+		operations.SupportedOptionTimeout,
 	}
 
-	baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
-	opURL, err := url.JoinPath(baseURL, "/security/resources")
+	for _, opt := range opts {
+		if err := opt(&o, supportedOptions...); err != nil {
+			return nil, fmt.Errorf("error applying option: %w", err)
+		}
+	}
+
+	baseURL := utils.ReplaceParameters(operations.PostUsersSignInDataServerList[0], map[string]string{})
+	if o.ServerURL != nil {
+		baseURL = *o.ServerURL
+	}
+
+	opURL, err := url.JoinPath(baseURL, "/users/signin")
 	if err != nil {
 		return nil, fmt.Errorf("error generating URL: %w", err)
 	}
 
-	req, err := http.NewRequestWithContext(ctx, "GET", opURL, nil)
+	hookCtx := hooks.HookContext{
+		SDK:              s.rootSDK,
+		SDKConfiguration: s.sdkConfiguration,
+		BaseURL:          baseURL,
+		Context:          ctx,
+		OperationID:      "post-users-sign-in-data",
+		OAuth2Scopes:     nil,
+		SecuritySource:   nil,
+	}
+	bodyReader, reqContentType, err := utils.SerializeRequestBody(ctx, request, false, true, "RequestBody", "form", `request:"mediaType=application/x-www-form-urlencoded"`)
+	if err != nil {
+		return nil, err
+	}
+
+	timeout := o.Timeout
+	if timeout == nil {
+		timeout = s.sdkConfiguration.Timeout
+	}
+
+	if timeout != nil {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, *timeout)
+		defer cancel()
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "POST", opURL, bodyReader)
 	if err != nil {
 		return nil, fmt.Errorf("error creating request: %w", err)
 	}
 	req.Header.Set("Accept", "application/json")
 	req.Header.Set("User-Agent", s.sdkConfiguration.UserAgent)
-
-	if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
-		return nil, fmt.Errorf("error populating query params: %w", err)
+	if reqContentType != "" {
+		req.Header.Set("Content-Type", reqContentType)
 	}
 
-	if err := utils.PopulateSecurity(ctx, req, s.sdkConfiguration.Security); err != nil {
-		return nil, err
+	utils.PopulateHeaders(ctx, req, request, globals)
+
+	for k, v := range o.SetHeaders {
+		req.Header.Set(k, v)
 	}
 
-	req, err = s.sdkConfiguration.Hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
+	globalRetryConfig := s.sdkConfiguration.RetryConfig
+	retryConfig := o.Retries
+	if retryConfig == nil {
+		if globalRetryConfig != nil {
+			retryConfig = globalRetryConfig
+		}
+	}
+
+	var httpRes *http.Response
+	if retryConfig != nil {
+		httpRes, err = utils.Retry(ctx, utils.Retries{
+			Config: retryConfig,
+			StatusCodes: []string{
+				"429",
+				"500",
+				"502",
+				"503",
+				"504",
+			},
+		}, func() (*http.Response, error) {
+			if req.Body != nil && req.Body != http.NoBody && req.GetBody != nil {
+				copyBody, err := req.GetBody()
+
 				if err != nil {
 					return nil, err
 				}
 
+				req.Body = copyBody
+			}
+
+			req, err = s.hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
+			if err != nil {
+				if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
+					return nil, err
+				}
+
+				return nil, retry.Permanent(err)
+			}
+
 			httpRes, err := s.sdkConfiguration.Client.Do(req)
 			if err != nil || httpRes == nil {
 				if err != nil {
@@ -179,45 +422,87 @@ func (s *Authentication) GetSourceConnectionInformation(ctx context.Context, sou
 					err = fmt.Errorf("error sending request: no response")
 				}
 
-		_, err = s.sdkConfiguration.Hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+				_, err = s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+			}
+			return httpRes, err
+		})
+
+		if err != nil {
 			return nil, err
-	} else if utils.MatchStatusCodes([]string{"400", "401", "4XX", "5XX"}, httpRes.StatusCode) {
-		httpRes, err = s.sdkConfiguration.Hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, httpRes, nil)
+		} else {
+			httpRes, err = s.hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
 			if err != nil {
 				return nil, err
 			}
+		}
 	} else {
-		httpRes, err = s.sdkConfiguration.Hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
+		req, err = s.hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
 		if err != nil {
 			return nil, err
 		}
+
+		httpRes, err = s.sdkConfiguration.Client.Do(req)
+		if err != nil || httpRes == nil {
+			if err != nil {
+				err = fmt.Errorf("error sending request: %w", err)
+			} else {
+				err = fmt.Errorf("error sending request: no response")
+			}
+
+			_, err = s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+			return nil, err
+		} else if utils.MatchStatusCodes([]string{"400", "401", "4XX", "5XX"}, httpRes.StatusCode) {
+			_httpRes, err := s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, httpRes, nil)
+			if err != nil {
+				return nil, err
+			} else if _httpRes != nil {
+				httpRes = _httpRes
+			}
+		} else {
+			httpRes, err = s.hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
+			if err != nil {
+				return nil, err
+			}
+		}
 	}
 
-	res := &operations.GetSourceConnectionInformationResponse{
+	res := &operations.PostUsersSignInDataResponse{
 		StatusCode:  httpRes.StatusCode,
 		ContentType: httpRes.Header.Get("Content-Type"),
 		RawResponse: httpRes,
 	}
 
-	rawBody, err := io.ReadAll(httpRes.Body)
-	if err != nil {
-		return nil, fmt.Errorf("error reading response body: %w", err)
-	}
-	httpRes.Body.Close()
-	httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
-
 	switch {
-	case httpRes.StatusCode == 200:
-	case httpRes.StatusCode == 400:
-		fallthrough
-	case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
-		fallthrough
-	case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
-		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
-	case httpRes.StatusCode == 401:
+	case httpRes.StatusCode == 201:
 		switch {
 		case utils.MatchContentType(httpRes.Header.Get("Content-Type"), `application/json`):
-			var out sdkerrors.GetSourceConnectionInformationResponseBody
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
+
+			var out operations.PostUsersSignInDataUserPlexAccount
+			if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
+				return nil, err
+			}
+
+			res.UserPlexAccount = &out
+		default:
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
+			return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", httpRes.Header.Get("Content-Type")), httpRes.StatusCode, string(rawBody), httpRes)
+		}
+	case httpRes.StatusCode == 400:
+		switch {
+		case utils.MatchContentType(httpRes.Header.Get("Content-Type"), `application/json`):
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
+
+			var out sdkerrors.PostUsersSignInDataBadRequest
 			if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
 				return nil, err
 			}
@@ -225,11 +510,54 @@ func (s *Authentication) GetSourceConnectionInformation(ctx context.Context, sou
 			out.RawResponse = httpRes
 			return nil, &out
 		default:
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
 			return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", httpRes.Header.Get("Content-Type")), httpRes.StatusCode, string(rawBody), httpRes)
 		}
+	case httpRes.StatusCode == 401:
+		switch {
+		case utils.MatchContentType(httpRes.Header.Get("Content-Type"), `application/json`):
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
+
+			var out sdkerrors.PostUsersSignInDataUnauthorized
+			if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
+				return nil, err
+			}
+
+			out.RawResponse = httpRes
+			return nil, &out
 		default:
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
+			return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", httpRes.Header.Get("Content-Type")), httpRes.StatusCode, string(rawBody), httpRes)
+		}
+	case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
+		}
+		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
+	case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
+		}
+		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
+	default:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
+		}
 		return nil, sdkerrors.NewSDKError("unknown status code returned", httpRes.StatusCode, string(rawBody), httpRes)
 	}
 
 	return res, nil
+
 }

collections.go

@@ -0,0 +1,260 @@
+// Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+package plexgo
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"github.com/LukeHagar/plexgo/internal/config"
+	"github.com/LukeHagar/plexgo/internal/hooks"
+	"github.com/LukeHagar/plexgo/internal/utils"
+	"github.com/LukeHagar/plexgo/models/components"
+	"github.com/LukeHagar/plexgo/models/operations"
+	"github.com/LukeHagar/plexgo/models/sdkerrors"
+	"github.com/LukeHagar/plexgo/retry"
+	"net/http"
+	"net/url"
+)
+
+// Collections - API Operations against the Collections
+type Collections struct {
+	rootSDK          *PlexAPI
+	sdkConfiguration config.SDKConfiguration
+	hooks            *hooks.Hooks
+}
+
+func newCollections(rootSDK *PlexAPI, sdkConfig config.SDKConfiguration, hooks *hooks.Hooks) *Collections {
+	return &Collections{
+		rootSDK:          rootSDK,
+		sdkConfiguration: sdkConfig,
+		hooks:            hooks,
+	}
+}
+
+// CreateCollection - Create collection
+// Create a collection in the library
+func (s *Collections) CreateCollection(ctx context.Context, request operations.CreateCollectionRequest, opts ...operations.Option) (*operations.CreateCollectionResponse, error) {
+	globals := operations.CreateCollectionGlobals{
+		Accepts:          s.sdkConfiguration.Globals.Accepts,
+		ClientIdentifier: s.sdkConfiguration.Globals.ClientIdentifier,
+		Product:          s.sdkConfiguration.Globals.Product,
+		Version:          s.sdkConfiguration.Globals.Version,
+		Platform:         s.sdkConfiguration.Globals.Platform,
+		PlatformVersion:  s.sdkConfiguration.Globals.PlatformVersion,
+		Device:           s.sdkConfiguration.Globals.Device,
+		Model:            s.sdkConfiguration.Globals.Model,
+		DeviceVendor:     s.sdkConfiguration.Globals.DeviceVendor,
+		DeviceName:       s.sdkConfiguration.Globals.DeviceName,
+		Marketplace:      s.sdkConfiguration.Globals.Marketplace,
+	}
+
+	o := operations.Options{}
+	supportedOptions := []string{
+		operations.SupportedOptionRetries,
+		operations.SupportedOptionTimeout,
+	}
+
+	for _, opt := range opts {
+		if err := opt(&o, supportedOptions...); err != nil {
+			return nil, fmt.Errorf("error applying option: %w", err)
+		}
+	}
+
+	var baseURL string
+	if o.ServerURL == nil {
+		baseURL = utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
+	} else {
+		baseURL = *o.ServerURL
+	}
+	opURL, err := url.JoinPath(baseURL, "/library/collections")
+	if err != nil {
+		return nil, fmt.Errorf("error generating URL: %w", err)
+	}
+
+	hookCtx := hooks.HookContext{
+		SDK:              s.rootSDK,
+		SDKConfiguration: s.sdkConfiguration,
+		BaseURL:          baseURL,
+		Context:          ctx,
+		OperationID:      "createCollection",
+		OAuth2Scopes:     nil,
+		SecuritySource:   s.sdkConfiguration.Security,
+	}
+
+	timeout := o.Timeout
+	if timeout == nil {
+		timeout = s.sdkConfiguration.Timeout
+	}
+
+	if timeout != nil {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, *timeout)
+		defer cancel()
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "POST", opURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request: %w", err)
+	}
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("User-Agent", s.sdkConfiguration.UserAgent)
+
+	utils.PopulateHeaders(ctx, req, request, globals)
+
+	if err := utils.PopulateQueryParams(ctx, req, request, globals, nil); err != nil {
+		return nil, fmt.Errorf("error populating query params: %w", err)
+	}
+
+	if err := utils.PopulateSecurity(ctx, req, s.sdkConfiguration.Security); err != nil {
+		return nil, err
+	}
+
+	for k, v := range o.SetHeaders {
+		req.Header.Set(k, v)
+	}
+
+	globalRetryConfig := s.sdkConfiguration.RetryConfig
+	retryConfig := o.Retries
+	if retryConfig == nil {
+		if globalRetryConfig != nil {
+			retryConfig = globalRetryConfig
+		}
+	}
+
+	var httpRes *http.Response
+	if retryConfig != nil {
+		httpRes, err = utils.Retry(ctx, utils.Retries{
+			Config: retryConfig,
+			StatusCodes: []string{
+				"429",
+				"500",
+				"502",
+				"503",
+				"504",
+			},
+		}, func() (*http.Response, error) {
+			if req.Body != nil && req.Body != http.NoBody && req.GetBody != nil {
+				copyBody, err := req.GetBody()
+
+				if err != nil {
+					return nil, err
+				}
+
+				req.Body = copyBody
+			}
+
+			req, err = s.hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
+			if err != nil {
+				if retry.IsPermanentError(err) || retry.IsTemporaryError(err) {
+					return nil, err
+				}
+
+				return nil, retry.Permanent(err)
+			}
+
+			httpRes, err := s.sdkConfiguration.Client.Do(req)
+			if err != nil || httpRes == nil {
+				if err != nil {
+					err = fmt.Errorf("error sending request: %w", err)
+				} else {
+					err = fmt.Errorf("error sending request: no response")
+				}
+
+				_, err = s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+			}
+			return httpRes, err
+		})
+
+		if err != nil {
+			return nil, err
+		} else {
+			httpRes, err = s.hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
+			if err != nil {
+				return nil, err
+			}
+		}
+	} else {
+		req, err = s.hooks.BeforeRequest(hooks.BeforeRequestContext{HookContext: hookCtx}, req)
+		if err != nil {
+			return nil, err
+		}
+
+		httpRes, err = s.sdkConfiguration.Client.Do(req)
+		if err != nil || httpRes == nil {
+			if err != nil {
+				err = fmt.Errorf("error sending request: %w", err)
+			} else {
+				err = fmt.Errorf("error sending request: no response")
+			}
+
+			_, err = s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, nil, err)
+			return nil, err
+		} else if utils.MatchStatusCodes([]string{"400", "4XX", "5XX"}, httpRes.StatusCode) {
+			_httpRes, err := s.hooks.AfterError(hooks.AfterErrorContext{HookContext: hookCtx}, httpRes, nil)
+			if err != nil {
+				return nil, err
+			} else if _httpRes != nil {
+				httpRes = _httpRes
+			}
+		} else {
+			httpRes, err = s.hooks.AfterSuccess(hooks.AfterSuccessContext{HookContext: hookCtx}, httpRes)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	res := &operations.CreateCollectionResponse{
+		StatusCode:  httpRes.StatusCode,
+		ContentType: httpRes.Header.Get("Content-Type"),
+		RawResponse: httpRes,
+	}
+
+	switch {
+	case httpRes.StatusCode == 200:
+		switch {
+		case utils.MatchContentType(httpRes.Header.Get("Content-Type"), `application/json`):
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
+
+			var out components.MediaContainerWithMetadata
+			if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
+				return nil, err
+			}
+
+			res.MediaContainerWithMetadata = &out
+		default:
+			rawBody, err := utils.ConsumeRawBody(httpRes)
+			if err != nil {
+				return nil, err
+			}
+			return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", httpRes.Header.Get("Content-Type")), httpRes.StatusCode, string(rawBody), httpRes)
+		}
+	case httpRes.StatusCode == 400:
+		fallthrough
+	case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
+		}
+		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
+	case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
+		}
+		return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
+	default:
+		rawBody, err := utils.ConsumeRawBody(httpRes)
+		if err != nil {
+			return nil, err
+		}
+		return nil, sdkerrors.NewSDKError("unknown status code returned", httpRes.StatusCode, string(rawBody), httpRes)
+	}
+
+	return res, nil
+
+}

docs/models/components/accepts.md

@@ -0,0 +1,9 @@
+# Accepts
+
+
+## Values
+
+| Name                     | Value                    |
+| ------------------------ | ------------------------ |
+| `AcceptsApplicationJSON` | application/json         |
+| `AcceptsApplicationXML`  | application/xml          |

docs/models/components/advancedsubtitles.md

@@ -0,0 +1,10 @@
+# AdvancedSubtitles
+
+
+## Values
+
+| Name                       | Value                      |
+| -------------------------- | -------------------------- |
+| `AdvancedSubtitlesBurn`    | burn                       |
+| `AdvancedSubtitlesText`    | text                       |
+| `AdvancedSubtitlesUnknown` | unknown                    |

docs/models/components/airingstype.md

@@ -0,0 +1,9 @@
+# AiringsType
+
+
+## Values
+
+| Name                             | Value                            |
+| -------------------------------- | -------------------------------- |
+| `AiringsTypeNewAiringsOnly`      | New Airings Only                 |
+| `AiringsTypeNewAndRepeatAirings` | New and Repeat Airings           |

docs/models/components/autoselectsubtitle.md

@@ -0,0 +1,12 @@
+# AutoSelectSubtitle
+
+The auto-select subtitle mode (0 = Manually selected, 1 = Shown with foreign audio, 2 = Always enabled)
+
+
+## Values
+
+| Name                                      | Value                                     |
+| ----------------------------------------- | ----------------------------------------- |
+| `AutoSelectSubtitleManuallySelected`      | 0                                         |
+| `AutoSelectSubtitleShownWithForeignAudio` | 1                                         |
+| `AutoSelectSubtitleAlwaysEnabled`         | 2                                         |

docs/models/components/boolint.md

@@ -0,0 +1,9 @@
+# BoolInt
+
+
+## Values
+
+| Name           | Value          |
+| -------------- | -------------- |
+| `BoolIntFalse` | 0              |
+| `BoolIntTrue`  | 1              |

docs/models/components/channel.md

@@ -0,0 +1,15 @@
+# Channel
+
+
+## Fields
+
+| Field              | Type               | Required           | Description        |
+| ------------------ | ------------------ | ------------------ | ------------------ |
+| `Title`            | **string*          | :heavy_minus_sign: | N/A                |
+| `CallSign`         | **string*          | :heavy_minus_sign: | N/A                |
+| `ChannelVcn`       | **string*          | :heavy_minus_sign: | N/A                |
+| `Hd`               | **bool*            | :heavy_minus_sign: | N/A                |
+| `Identifier`       | **string*          | :heavy_minus_sign: | N/A                |
+| `Key`              | **string*          | :heavy_minus_sign: | N/A                |
+| `Language`         | **string*          | :heavy_minus_sign: | N/A                |
+| `Thumb`            | **string*          | :heavy_minus_sign: | N/A                |

docs/models/components/channelmapping.md

@@ -0,0 +1,11 @@
+# ChannelMapping
+
+
+## Fields
+
+| Field              | Type               | Required           | Description        |
+| ------------------ | ------------------ | ------------------ | ------------------ |
+| `ChannelKey`       | **string*          | :heavy_minus_sign: | N/A                |
+| `DeviceIdentifier` | **string*          | :heavy_minus_sign: | N/A                |
+| `Enabled`          | **string*          | :heavy_minus_sign: | N/A                |
+| `LineupIdentifier` | **string*          | :heavy_minus_sign: | N/A                |

docs/models/components/composite.md

@@ -0,0 +1,18 @@
+# Composite
+
+
+## Fields
+
+| Field                                                                       | Type                                                                        | Required                                                                    | Description                                                                 |
+| --------------------------------------------------------------------------- | --------------------------------------------------------------------------- | --------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| `Type`                                                                      | **int64*                                                                    | :heavy_minus_sign:                                                          | Limit composite to specified metadata types                                 |
+| `Format`                                                                    | [*components.Format](../../models/components/format.md)                     | :heavy_minus_sign:                                                          | The image type                                                              |
+| `BackgroundColor`                                                           | **string*                                                                   | :heavy_minus_sign:                                                          | 6 character hex RGB value for background color for image                    |
+| `Border`                                                                    | **int64*                                                                    | :heavy_minus_sign:                                                          | The width of the intra-image border                                         |
+| `Cols`                                                                      | **int64*                                                                    | :heavy_minus_sign:                                                          | Number of columns to construct in the composite image                       |
+| `Crop`                                                                      | [*components.Crop](../../models/components/crop.md)                         | :heavy_minus_sign:                                                          | Where to crop source images to fit into composite image proportions         |
+| `Height`                                                                    | **int64*                                                                    | :heavy_minus_sign:                                                          | The height of the image                                                     |
+| `Media`                                                                     | [*components.CompositeMedia](../../models/components/compositemedia.md)     | :heavy_minus_sign:                                                          | The default image type to use as the sources                                |
+| `Repeat`                                                                    | **bool*                                                                     | :heavy_minus_sign:                                                          | Allow repetion of images if there are not enough source images to fill grid |
+| `Rows`                                                                      | **int64*                                                                    | :heavy_minus_sign:                                                          | Number of rows to construct in the composite image                          |
+| `Width`                                                                     | **int64*                                                                    | :heavy_minus_sign:                                                          | The width of the image                                                      |

docs/models/components/compositemedia.md

@@ -0,0 +1,12 @@
+# CompositeMedia
+
+The default image type to use as the sources
+
+
+## Values
+
+| Name                   | Value                  |
+| ---------------------- | ---------------------- |
+| `CompositeMediaThumb`  | thumb                  |
+| `CompositeMediaArt`    | art                    |
+| `CompositeMediaBanner` | banner                 |

docs/models/components/connections.md

@@ -0,0 +1,14 @@
+# Connections
+
+
+## Fields
+
+| Field                                                                          | Type                                                                           | Required                                                                       | Description                                                                    | Example                                                                        |
+| ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------ |
+| `Protocol`                                                                     | [components.PlexDeviceProtocol](../../models/components/plexdeviceprotocol.md) | :heavy_check_mark:                                                             | The protocol used for the connection (http, https, etc)                        | http                                                                           |
+| `Address`                                                                      | *string*                                                                       | :heavy_check_mark:                                                             | The (ip) address or domain name used for the connection                        |                                                                                |
+| `Port`                                                                         | *int*                                                                          | :heavy_check_mark:                                                             | The port used for the connection                                               |                                                                                |
+| `URI`                                                                          | *string*                                                                       | :heavy_check_mark:                                                             | The full URI of the connection                                                 |                                                                                |
+| `Local`                                                                        | *bool*                                                                         | :heavy_check_mark:                                                             | If the connection is local address                                             |                                                                                |
+| `Relay`                                                                        | *bool*                                                                         | :heavy_check_mark:                                                             | If the connection is relayed through plex.direct                               |                                                                                |
+| `IPv6`                                                                         | *bool*                                                                         | :heavy_check_mark:                                                             | If the connection is using IPv6                                                |                                                                                |

docs/models/components/crop.md

@@ -0,0 +1,11 @@
+# Crop
+
+Where to crop source images to fit into composite image proportions
+
+
+## Values
+
+| Name         | Value        |
+| ------------ | ------------ |
+| `CropCenter` | center       |
+| `CropTop`    | top          |

docs/models/components/decision.md

@@ -0,0 +1,10 @@
+# Decision
+
+
+## Values
+
+| Name                 | Value                |
+| -------------------- | -------------------- |
+| `DecisionDirectplay` | directplay           |
+| `DecisionTranscode`  | transcode            |
+| `DecisionNone`       | none                 |

docs/models/components/default.md

@@ -0,0 +1,25 @@
+# Default
+
+The default value of this setting
+
+
+## Supported Types
+
+### 
+
+```go
+default := components.CreateDefaultStr(string{/* values here */})
+```
+
+### 
+
+```go
+default := components.CreateDefaultNumber(float64{/* values here */})
+```
+
+### 
+
+```go
+default := components.CreateDefaultBoolean(bool{/* values here */})
+```
+

docs/models/components/defaultaudioaccessibility.md

@@ -0,0 +1,13 @@
+# DefaultAudioAccessibility
+
+The audio accessibility mode (0 = Prefer non-accessibility audio, 1 = Prefer accessibility audio, 2 = Only show accessibility audio, 3 = Only show non-accessibility audio)
+
+
+## Values
+
+| Name                                              | Value                                             |
+| ------------------------------------------------- | ------------------------------------------------- |
+| `DefaultAudioAccessibilityPreferNonAccessibility` | 0                                                 |
+| `DefaultAudioAccessibilityPreferAccessibility`    | 1                                                 |
+| `DefaultAudioAccessibilityOnlyAccessibility`      | 2                                                 |
+| `DefaultAudioAccessibilityOnlyNonAccessibility`   | 3                                                 |

docs/models/components/defaultdirection.md

@@ -0,0 +1,11 @@
+# DefaultDirection
+
+This default diction of this sort
+
+
+## Values
+
+| Name                   | Value                  |
+| ---------------------- | ---------------------- |
+| `DefaultDirectionAsc`  | asc                    |
+| `DefaultDirectionDesc` | desc                   |

docs/models/components/defaultsubtitleaccessibility.md

@@ -0,0 +1,13 @@
+# DefaultSubtitleAccessibility
+
+The subtitles for the deaf or hard-of-hearing (SDH) searches mode (0 = Prefer non-SDH subtitles, 1 = Prefer SDH subtitles, 2 = Only show SDH subtitles, 3 = Only show non-SDH subtitles)
+
+
+## Values
+
+| Name                                       | Value                                      |
+| ------------------------------------------ | ------------------------------------------ |
+| `DefaultSubtitleAccessibilityPreferNonSdh` | 0                                          |
+| `DefaultSubtitleAccessibilityPreferSdh`    | 1                                          |
+| `DefaultSubtitleAccessibilityOnlySdh`      | 2                                          |
+| `DefaultSubtitleAccessibilityOnlyNonSdh`   | 3                                          |

docs/models/components/defaultsubtitleforced.md

@@ -0,0 +1,13 @@
+# DefaultSubtitleForced
+
+The forced subtitles searches mode (0 = Prefer non-forced subtitles, 1 = Prefer forced subtitles, 2 = Only show forced subtitles, 3 = Only show non-forced subtitles)
+
+
+## Values
+
+| Name                                   | Value                                  |
+| -------------------------------------- | -------------------------------------- |
+| `DefaultSubtitleForcedPreferNonForced` | 0                                      |
+| `DefaultSubtitleForcedPreferForced`    | 1                                      |
+| `DefaultSubtitleForcedOnlyForced`      | 2                                      |
+| `DefaultSubtitleForcedOnlyNonForced`   | 3                                      |

docs/models/components/device.md

@@ -0,0 +1,20 @@
+# Device
+
+
+## Fields
+
+| Field                                                                    | Type                                                                     | Required                                                                 | Description                                                              |
+| ------------------------------------------------------------------------ | ------------------------------------------------------------------------ | ------------------------------------------------------------------------ | ------------------------------------------------------------------------ |
+| `ChannelMapping`                                                         | [][components.ChannelMapping](../../models/components/channelmapping.md) | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Key`                                                                    | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `LastSeenAt`                                                             | **int64*                                                                 | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Make`                                                                   | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Model`                                                                  | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `ModelNumber`                                                            | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Protocol`                                                               | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Sources`                                                                | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `State`                                                                  | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Status`                                                                 | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Tuners`                                                                 | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `URI`                                                                    | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `UUID`                                                                   | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |

docs/models/components/directory.md

@@ -0,0 +1,23 @@
+# Directory
+
+
+## Fields
+
+| Field                                                  | Type                                                   | Required                                               | Description                                            |
+| ------------------------------------------------------ | ------------------------------------------------------ | ------------------------------------------------------ | ------------------------------------------------------ |
+| `Title`                                                | **string*                                              | :heavy_minus_sign:                                     | N/A                                                    |
+| `Type`                                                 | **string*                                              | :heavy_minus_sign:                                     | N/A                                                    |
+| `Art`                                                  | **string*                                              | :heavy_minus_sign:                                     | N/A                                                    |
+| `Content`                                              | **bool*                                                | :heavy_minus_sign:                                     | N/A                                                    |
+| `Filter`                                               | **string*                                              | :heavy_minus_sign:                                     | N/A                                                    |
+| `HasPrefs`                                             | **bool*                                                | :heavy_minus_sign:                                     | N/A                                                    |
+| `HasStoreServices`                                     | **bool*                                                | :heavy_minus_sign:                                     | N/A                                                    |
+| `HubKey`                                               | **string*                                              | :heavy_minus_sign:                                     | N/A                                                    |
+| `Identifier`                                           | **string*                                              | :heavy_minus_sign:                                     | N/A                                                    |
+| `Key`                                                  | **string*                                              | :heavy_minus_sign:                                     | N/A                                                    |
+| `LastAccessedAt`                                       | **int64*                                               | :heavy_minus_sign:                                     | N/A                                                    |
+| `Pivot`                                                | [][components.Pivot](../../models/components/pivot.md) | :heavy_minus_sign:                                     | N/A                                                    |
+| `Share`                                                | **int64*                                               | :heavy_minus_sign:                                     | N/A                                                    |
+| `Thumb`                                                | **string*                                              | :heavy_minus_sign:                                     | N/A                                                    |
+| `TitleBar`                                             | **string*                                              | :heavy_minus_sign:                                     | N/A                                                    |
+| `AdditionalProperties`                                 | map[string]*any*                                       | :heavy_minus_sign:                                     | N/A                                                    |

docs/models/components/dvr.md

@@ -0,0 +1,12 @@
+# Dvr
+
+
+## Fields
+
+| Field                                                    | Type                                                     | Required                                                 | Description                                              |
+| -------------------------------------------------------- | -------------------------------------------------------- | -------------------------------------------------------- | -------------------------------------------------------- |
+| `Device`                                                 | [][components.Device](../../models/components/device.md) | :heavy_minus_sign:                                       | N/A                                                      |
+| `Key`                                                    | **string*                                                | :heavy_minus_sign:                                       | N/A                                                      |
+| `Language`                                               | **string*                                                | :heavy_minus_sign:                                       | N/A                                                      |
+| `Lineup`                                                 | **string*                                                | :heavy_minus_sign:                                       | N/A                                                      |
+| `UUID`                                                   | **string*                                                | :heavy_minus_sign:                                       | N/A                                                      |

docs/models/components/dvrrequesthandlerslashgetresponses200.md

@@ -0,0 +1,10 @@
+# DvrRequestHandlerSlashGetResponses200
+
+OK
+
+
+## Fields
+
+| Field                                                                                                                                             | Type                                                                                                                                              | Required                                                                                                                                          | Description                                                                                                                                       |
+| ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `MediaContainer`                                                                                                                                  | [*components.DvrRequestHandlerSlashGetResponses200MediaContainer](../../models/components/dvrrequesthandlerslashgetresponses200mediacontainer.md) | :heavy_minus_sign:                                                                                                                                | N/A                                                                                                                                               |

docs/models/components/dvrrequesthandlerslashgetresponses200mediacontainer.md

@@ -1,9 +1,9 @@
-# GetTokenRequest
+# DvrRequestHandlerSlashGetResponses200MediaContainer
 
 
 ## Fields
 
 | Field                                                                                                                                                                         | Type                                                                                                                                                                          | Required                                                                                                                                                                      | Description                                                                                                                                                                   |
-| --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `PinID`                                                                                                                                                               | *string*                                                                                                                                                              | :heavy_check_mark:                                                                                                                                                    | The PinID to retrieve an access token for                                                                                                                             |
-| `XPlexClientIdentifier`                                                                                                                                               | **string*                                                                                                                                                             | :heavy_minus_sign:                                                                                                                                                    | The unique identifier for the client application<br/>This is used to track the client application and its usage<br/>(UUID, serial number, or other number unique per device)<br/> |
+| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `MediaContainer`                                                                                                                                                              | [*components.DvrRequestHandlerSlashGetResponses200MediaContainerMediaContainer](../../models/components/dvrrequesthandlerslashgetresponses200mediacontainermediacontainer.md) | :heavy_minus_sign:                                                                                                                                                            | N/A                                                                                                                                                                           |
+| `Dvr`                                                                                                                                                                         | [][components.Dvr](../../models/components/dvr.md)                                                                                                                            | :heavy_minus_sign:                                                                                                                                                            | N/A                                                                                                                                                                           |

docs/models/components/dvrrequesthandlerslashgetresponses200mediacontainermediacontainer.md

@@ -0,0 +1,17 @@
+# DvrRequestHandlerSlashGetResponses200MediaContainerMediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
+
+
+## Fields
+
+| Field                                                                                                                                    | Type                                                                                                                                     | Required                                                                                                                                 | Description                                                                                                                              |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                             | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `Offset`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/> |
+| `Size`                                                                                                                                   | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `TotalSize`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                     |
+| `Status`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | A status indicator. If present and non-zero, indicates an error                                                                          |

docs/models/components/filter.md

@@ -1,11 +1,27 @@
-# GetLibrariesMediaContainer
+# Filter
+
+Each `Filter` object contains a description of the filter. Note that it is not an exhaustive list of the full media query language, but an important subset useful for top-level API.
+
 
 
 ## Fields
 
-| Field                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | Type                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Required                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Example                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Size`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 5                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| `AllowSync`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | **bool*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | false                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `Title1`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Plex Library                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `Directory`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [][operations.GetLibrariesDirectory](../../models/operations/getlibrariesdirectory.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | [<br/>{<br/>"allowSync": true,<br/>"art": "/:/resources/movie-fanart.jpg",<br/>"composite": "/library/sections/1/composite/1705615584",<br/>"filters": true,<br/>"refreshing": false,<br/>"thumb": "/:/resources/movie.png",<br/>"key": "1",<br/>"type": "movie",<br/>"title": "Movies",<br/>"agent": "tv.plex.agents.movie",<br/>"scanner": "Plex Movie",<br/>"language": "en-US",<br/>"uuid": "322a231a-b7f7-49f5-920f-14c61199cd30",<br/>"updatedAt": 1705615634,<br/>"createdAt": 1654131312,<br/>"scannedAt": 1705615584,<br/>"content": true,<br/>"directory": true,<br/>"contentChangedAt": 3192854,<br/>"hidden": 0,<br/>"Location": [<br/>{<br/>"id": 1,<br/>"path": "/movies"<br/>}<br/>]<br/>}<br/>] |
+| Field                                                                                                                                                                                                                                                                  | Type                                                                                                                                                                                                                                                                   | Required                                                                                                                                                                                                                                                               | Description                                                                                                                                                                                                                                                            |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Title`                                                                                                                                                                                                                                                                | **string*                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                     | The title for the filter.                                                                                                                                                                                                                                              |
+| `Type`                                                                                                                                                                                                                                                                 | **string*                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                    |
+| `Art`                                                                                                                                                                                                                                                                  | **string*                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                    |
+| `Content`                                                                                                                                                                                                                                                              | **bool*                                                                                                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                    |
+| `Filter`                                                                                                                                                                                                                                                               | **string*                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                     | This represents the filter name used for the filter, which can be used to construct complex media queries with.                                                                                                                                                        |
+| `HasPrefs`                                                                                                                                                                                                                                                             | **bool*                                                                                                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                    |
+| `HasStoreServices`                                                                                                                                                                                                                                                     | **bool*                                                                                                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                    |
+| `HubKey`                                                                                                                                                                                                                                                               | **string*                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                    |
+| `Identifier`                                                                                                                                                                                                                                                           | **string*                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                    |
+| `Key`                                                                                                                                                                                                                                                                  | **string*                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                     | This provides the endpoint where the possible range of values for the filter can be retrieved (e.g. for a "Genre" filter, it returns a list of all the genres in the library). This will include a `type` argument that matches the metadata type of the Type element. |
+| `LastAccessedAt`                                                                                                                                                                                                                                                       | **int64*                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                    |
+| `Pivot`                                                                                                                                                                                                                                                                | [][components.FilterPivot](../../models/components/filterpivot.md)                                                                                                                                                                                                     | :heavy_minus_sign:                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                    |
+| `Share`                                                                                                                                                                                                                                                                | **int64*                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                    |
+| `Thumb`                                                                                                                                                                                                                                                                | **string*                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                    |
+| `TitleBar`                                                                                                                                                                                                                                                             | **string*                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                    |
+| `FilterType`                                                                                                                                                                                                                                                           | **string*                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                     | This is either `string`, `integer`, or `boolean`, and describes the type of values used for the filter.                                                                                                                                                                |
+| `AdditionalProperties`                                                                                                                                                                                                                                                 | map[string]*any*                                                                                                                                                                                                                                                       | :heavy_minus_sign:                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                    |

docs/models/components/filterpivot.md

@@ -0,0 +1,13 @@
+# FilterPivot
+
+
+## Fields
+
+| Field              | Type               | Required           | Description        |
+| ------------------ | ------------------ | ------------------ | ------------------ |
+| `Title`            | **string*          | :heavy_minus_sign: | N/A                |
+| `Type`             | **string*          | :heavy_minus_sign: | N/A                |
+| `Context`          | **string*          | :heavy_minus_sign: | N/A                |
+| `ID`               | **string*          | :heavy_minus_sign: | N/A                |
+| `Key`              | **string*          | :heavy_minus_sign: | N/A                |
+| `Symbol`           | **string*          | :heavy_minus_sign: | N/A                |

docs/models/components/format.md

@@ -0,0 +1,11 @@
+# Format
+
+The image type
+
+
+## Values
+
+| Name        | Value       |
+| ----------- | ----------- |
+| `FormatJpg` | jpg         |
+| `FormatPng` | png         |

docs/models/components/getresponses200.md

@@ -1,10 +1,10 @@
-# GetUpdateStatusResponseBody
+# GetResponses200
 
-The Server Updates
+OK
 
 
 ## Fields
 
 | Field                                                                                                 | Type                                                                                                  | Required                                                                                              | Description                                                                                           |
 | ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
-| `MediaContainer`                                                                                      | [*operations.GetUpdateStatusMediaContainer](../../models/operations/getupdatestatusmediacontainer.md) | :heavy_minus_sign:                                                                                    | N/A                                                                                                   |
+| `MediaContainer`                                                                                      | [*components.GetResponses200MediaContainer](../../models/components/getresponses200mediacontainer.md) | :heavy_minus_sign:                                                                                    | N/A                                                                                                   |

docs/models/components/getresponses200hub.md

@@ -0,0 +1,14 @@
+# GetResponses200Hub
+
+
+## Fields
+
+| Field                                                                                                                                                                                  | Type                                                                                                                                                                                   | Required                                                                                                                                                                               | Description                                                                                                                                                                            |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `HomeVisibility`                                                                                                                                                                       | [*components.HomeVisibility](../../models/components/homevisibility.md)                                                                                                                | :heavy_minus_sign:                                                                                                                                                                     | Whether this hub is visible on the home screen<br/>  - all: Visible to all users<br/>  - none: Visible to no users<br/>  - admin: Visible to only admin users<br/>  - shared: Visible to shared users<br/> |
+| `Identifier`                                                                                                                                                                           | **string*                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                     | The identifier for this hub                                                                                                                                                            |
+| `PromotedToOwnHome`                                                                                                                                                                    | **bool*                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                     | Whether this hub is visible to admin user home                                                                                                                                         |
+| `PromotedToRecommended`                                                                                                                                                                | **bool*                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                     | Whether this hub is promoted to all for recommendations                                                                                                                                |
+| `PromotedToSharedHome`                                                                                                                                                                 | **bool*                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                     | Whether this hub is visible to shared user's home                                                                                                                                      |
+| `RecommendationsVisibility`                                                                                                                                                            | [*components.RecommendationsVisibility](../../models/components/recommendationsvisibility.md)                                                                                          | :heavy_minus_sign:                                                                                                                                                                     | The visibility of this hub in recommendations:<br/>  - all: Visible to all users<br/>  - none: Visible to no users<br/>  - admin: Visible to only admin users<br/>  - shared: Visible to shared users<br/> |
+| `Title`                                                                                                                                                                                | **string*                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                     | The title of this hub                                                                                                                                                                  |

docs/models/components/getresponses200mediacontainer.md

@@ -0,0 +1,17 @@
+# GetResponses200MediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
+
+
+## Fields
+
+| Field                                                                                                                                    | Type                                                                                                                                     | Required                                                                                                                                 | Description                                                                                                                              |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                             | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `Offset`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/> |
+| `Size`                                                                                                                                   | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `TotalSize`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                     |
+| `Hub`                                                                                                                                    | [][components.GetResponses200Hub](../../models/components/getresponses200hub.md)                                                         | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |

docs/models/components/guids.md

@@ -1,9 +1,8 @@
-# GetServerPreferencesMediaContainer
+# Guids
 
 
 ## Fields
 
 | Field                                                                                                                                                                                                                            | Type                                                                                                                                                                                                                             | Required                                                                                                                                                                                                                         | Description                                                                                                                                                                                                                      | Example                                                                                                                                                                                                                          |
-| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Size`                                                                                                                                                                                                     | **int*                                                                                                                                                                                                     | :heavy_minus_sign:                                                                                                                                                                                         | N/A                                                                                                                                                                                                        | 161                                                                                                                                                                                                        |
-| `Setting`                                                                                                                                                                                                  | [][operations.Setting](../../models/operations/setting.md)                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                                                         | N/A                                                                                                                                                                                                        | [<br/>{<br/>"id": "EnableDatabaseTrace",<br/>"label": "",<br/>"summary": "",<br/>"type": "bool",<br/>"default": false,<br/>"value": false,<br/>"hidden": true,<br/>"advanced": false,<br/>"group": "",<br/>"enumValues": "1:admin only\|2:everyone"<br/>}<br/>] |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ID`                                                                                                                                                                                                                             | *string*                                                                                                                                                                                                                         | :heavy_check_mark:                                                                                                                                                                                                               | The unique identifier for the Guid. Can be prefixed with imdb://, tmdb://, tvdb://<br/>                                                                                                                                          | {<br/>"imdbExample": {<br/>"summary": "IMDB example",<br/>"value": "imdb://tt13015952"<br/>},<br/>"tmdbExample": {<br/>"summary": "TMDB example",<br/>"value": "tmdb://2434012"<br/>},<br/>"tvdbExample": {<br/>"summary": "TVDB example",<br/>"value": "tvdb://7945991"<br/>}<br/>} |

docs/models/components/historyallgetresponses200.md

@@ -0,0 +1,10 @@
+# HistoryAllGetResponses200
+
+OK
+
+
+## Fields
+
+| Field                                                                                                                     | Type                                                                                                                      | Required                                                                                                                  | Description                                                                                                               |
+| ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| `MediaContainer`                                                                                                          | [*components.HistoryAllGetResponses200MediaContainer](../../models/components/historyallgetresponses200mediacontainer.md) | :heavy_minus_sign:                                                                                                        | N/A                                                                                                                       |

docs/models/components/historyallgetresponses200mediacontainer.md

@@ -0,0 +1,17 @@
+# HistoryAllGetResponses200MediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
+
+
+## Fields
+
+| Field                                                                                                                                    | Type                                                                                                                                     | Required                                                                                                                                 | Description                                                                                                                              |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                             | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `Offset`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/> |
+| `Size`                                                                                                                                   | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `TotalSize`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                     |
+| `Metadata`                                                                                                                               | [][components.HistoryAllGetResponses200Metadata](../../models/components/historyallgetresponses200metadata.md)                           | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |

docs/models/components/historyallgetresponses200metadata.md

@@ -0,0 +1,18 @@
+# HistoryAllGetResponses200Metadata
+
+
+## Fields
+
+| Field                                             | Type                                              | Required                                          | Description                                       |
+| ------------------------------------------------- | ------------------------------------------------- | ------------------------------------------------- | ------------------------------------------------- |
+| `AccountID`                                       | **int64*                                          | :heavy_minus_sign:                                | The account id of this playback                   |
+| `DeviceID`                                        | **int64*                                          | :heavy_minus_sign:                                | The device id which played the item               |
+| `HistoryKey`                                      | **string*                                         | :heavy_minus_sign:                                | The key for this individual history item          |
+| `Key`                                             | **string*                                         | :heavy_minus_sign:                                | The metadata key for the item played              |
+| `LibrarySectionID`                                | **string*                                         | :heavy_minus_sign:                                | The library section id containing the item played |
+| `OriginallyAvailableAt`                           | **string*                                         | :heavy_minus_sign:                                | The originally available at of the item played    |
+| `RatingKey`                                       | **string*                                         | :heavy_minus_sign:                                | The rating key for the item played                |
+| `Thumb`                                           | **string*                                         | :heavy_minus_sign:                                | The thumb of the item played                      |
+| `Title`                                           | **string*                                         | :heavy_minus_sign:                                | The title of the item played                      |
+| `Type`                                            | **string*                                         | :heavy_minus_sign:                                | The metadata type of the item played              |
+| `ViewedAt`                                        | **int64*                                          | :heavy_minus_sign:                                | The time when the item was played                 |

docs/models/components/homevisibility.md

@@ -0,0 +1,18 @@
+# HomeVisibility
+
+Whether this hub is visible on the home screen
+  - all: Visible to all users
+  - none: Visible to no users
+  - admin: Visible to only admin users
+  - shared: Visible to shared users
+
+
+
+## Values
+
+| Name                   | Value                  |
+| ---------------------- | ---------------------- |
+| `HomeVisibilityAll`    | all                    |
+| `HomeVisibilityNone`   | none                   |
+| `HomeVisibilityAdmin`  | admin                  |
+| `HomeVisibilityShared` | shared                 |

docs/models/components/hub.md

@@ -0,0 +1,22 @@
+# Hub
+
+
+## Fields
+
+| Field                                                                                                                                                                                                                  | Type                                                                                                                                                                                                                   | Required                                                                                                                                                                                                               | Description                                                                                                                                                                                                            | Example                                                                                                                                                                                                                |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Title`                                                                                                                                                                                                                | **string*                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                     | A title for this grouping of content                                                                                                                                                                                   |                                                                                                                                                                                                                        |
+| `Type`                                                                                                                                                                                                                 | **string*                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                     | The type of the items contained in this hub, or possibly `mixed` if there are multiple types                                                                                                                           | track                                                                                                                                                                                                                  |
+| `Context`                                                                                                                                                                                                              | **string*                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                    | hub.home.onDeck                                                                                                                                                                                                        |
+| `HubIdentifier`                                                                                                                                                                                                        | **string*                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                     | A unique identifier for the hub                                                                                                                                                                                        | home.onDeck                                                                                                                                                                                                            |
+| `HubKey`                                                                                                                                                                                                               | **string*                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                     | A key at which the exact content currently displayed can be fetched again. This is particularly important when a hub is marked as random and requesting the `key` may get different results. It's otherwise optional.<br/> |                                                                                                                                                                                                                        |
+| `Key`                                                                                                                                                                                                                  | **string*                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                     | The key at which all of the content for this hub can be retrieved                                                                                                                                                      | /hubs/sections/home/onDeck                                                                                                                                                                                             |
+| `Metadata`                                                                                                                                                                                                             | [][components.Metadata](../../models/components/metadata.md)                                                                                                                                                           | :heavy_minus_sign:                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                    |                                                                                                                                                                                                                        |
+| `More`                                                                                                                                                                                                                 | **bool*                                                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                                                     | "A boolean indicating that the hub contains more than what's included in the current response."<br/>                                                                                                                   |                                                                                                                                                                                                                        |
+| `Promoted`                                                                                                                                                                                                             | **bool*                                                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                                                     | Indicating if the hub should be promoted to the user's homescreen                                                                                                                                                      |                                                                                                                                                                                                                        |
+| `Random`                                                                                                                                                                                                               | **bool*                                                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                                                     | Indicating that the contents of the hub may change on each request                                                                                                                                                     |                                                                                                                                                                                                                        |
+| `Size`                                                                                                                                                                                                                 | **int64*                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                    | 1                                                                                                                                                                                                                      |
+| `Style`                                                                                                                                                                                                                | **string*                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                     | A suggestion on how this hub's contents might be displayed by a client. Some examples include `hero`, `list`, `spotlight`, and `upsell`                                                                                |                                                                                                                                                                                                                        |
+| `Subtype`                                                                                                                                                                                                              | **string*                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                     | The subtype of the items contained in this hub, or possibly `mixed` if there are multiple types                                                                                                                        | podcast                                                                                                                                                                                                                |
+| `TotalSize`                                                                                                                                                                                                            | **int64*                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                    | 8                                                                                                                                                                                                                      |
+| `AdditionalProperties`                                                                                                                                                                                                 | map[string]*any*                                                                                                                                                                                                       | :heavy_minus_sign:                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                    |                                                                                                                                                                                                                        |

docs/models/components/image.md

@@ -0,0 +1,13 @@
+# Image
+
+Images such as movie posters and background artwork are represented by Image elements.
+
+
+
+## Fields
+
+| Field                                                              | Type                                                               | Required                                                           | Description                                                        |
+| ------------------------------------------------------------------ | ------------------------------------------------------------------ | ------------------------------------------------------------------ | ------------------------------------------------------------------ |
+| `Type`                                                             | [*components.ImageType](../../models/components/imagetype.md)      | :heavy_minus_sign:                                                 | Describes both the purpose and intended presentation of the image. |
+| `Alt`                                                              | **string*                                                          | :heavy_minus_sign:                                                 | Title to use for accessibility.                                    |
+| `URL`                                                              | **string*                                                          | :heavy_minus_sign:                                                 | The relative path or absolute url for the image.                   |

docs/models/components/imagetype.md

@@ -0,0 +1,14 @@
+# ImageType
+
+Describes both the purpose and intended presentation of the image.
+
+
+## Values
+
+| Name                   | Value                  |
+| ---------------------- | ---------------------- |
+| `ImageTypeBackground`  | background             |
+| `ImageTypeBanner`      | banner                 |
+| `ImageTypeClearLogo`   | clearLogo              |
+| `ImageTypeCoverPoster` | coverPoster            |
+| `ImageTypeSnapshot`    | snapshot               |

docs/models/components/items.md

@@ -1,44 +1,87 @@
-# GetSessionsMetadata
+# Items
+
+Items in a library are referred to as "metadata items." These metadata items are distinct from "media items" which represent actual instances of media that can be consumed. Consider a TV library that has a single video file in it for a particular episode of a show. The library has a single media item, but it has three metadata items: one for the show, one for the season, and one for the episode. Consider a movie library that has two video files in it: the same movie, but two different resolutions. The library has a single metadata item for the movie, but that metadata item has two media items, one for each resolution. Additionally a "media item" will have one or more "media parts" where the the parts are intended to be watched together, such as a CD1 and CD2 parts of the same movie.
+
+Note that when a metadata item has multiple media items, those media items should be isomorphic. That is, a 4K version and 1080p version of a movie are different versions of the same movie. They have the same duration, same summary, same rating, etc. and they can generally be considered interchangeable. A theatrical release vs. director's cut vs. unrated version on the other hand would be separate metadata items.
+
+Metadata items can often live in a hierarchy with relationships between them.  For example, the metadata item for an episodes is associated with a season metadata item which is associated with a show metadata item.  A similar hierarchy exists with track, album, and artist and photos and photo album.  The relationships may be expressed via relative terms and absolute terms.  For example, "leaves" refer to metadata items which has associated media (there is no media for a season nor show).  A show will have "children" in the form of seasons and a season will have "children" in the form of episodes and episodes have "parent" in the form of a season which has a "parent" in the form of a show.  Similarly, a show has "grandchildren" in the form of episodse and an episode has a "grandparent" in the form of a show.
+
 
 
 ## Fields
 
 | Field                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Type                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Required                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Example                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `AddedAt`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 1705543312                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| `Art`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | /library/metadata/39904/art/1705310687                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `Duration`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 186240                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `GrandparentArt`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | /library/metadata/39904/art/1705310687                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `GrandparentGUID`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | plex://artist/5d07bbfd403c6402904a6480                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `GrandparentKey`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | /library/metadata/39904                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `GrandparentRatingKey`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 39904                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `GrandparentThumb`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | /library/metadata/39904/thumb/1705310687                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `GrandparentTitle`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Green Day                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `GUID`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | plex://track/6535834f71f22f36f71a8e8f                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `Index`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `Key`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | /library/metadata/67085                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `LibrarySectionID`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 3                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `LibrarySectionKey`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | /library/sections/3                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| `LibrarySectionTitle`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Music                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `MusicAnalysisVersion`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `ParentGUID`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | plex://album/65394d6d472b8ab03ef47f12                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `ParentIndex`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `ParentKey`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | /library/metadata/67084                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `ParentRatingKey`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 67084                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `ParentStudio`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Reprise Records                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `ParentThumb`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | /library/metadata/67084/thumb/1705543314                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `ParentTitle`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Saviors                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `ParentYear`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 2024                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `RatingCount`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 45885                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `RatingKey`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 67085                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `SessionKey`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 203                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| `Thumb`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | /library/metadata/67084/thumb/1705543314                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `Title`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | The American Dream Is Killing Me                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `TitleSort`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | American Dream Is Killing Me                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| `Type`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | track                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `UpdatedAt`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 1705543314                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| `ViewOffset`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 1000                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `Media`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | [][operations.GetSessionsMedia](../../models/operations/getsessionsmedia.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | [<br/>{<br/>"audioChannels": 2,<br/>"audioCodec": "flac",<br/>"bitrate": 1014,<br/>"container": "flac",<br/>"duration": 186240,<br/>"id": "130355",<br/>"selected": true,<br/>"Part": [<br/>{<br/>"container": "flac",<br/>"duration": 186240,<br/>"file": "/music/Green Day/Saviors (2024)/Green Day - Saviors - 01 - The American Dream Is Killing Me.flac",<br/>"hasThumbnail": "1",<br/>"id": "130625",<br/>"key": "/library/parts/130625/1705543268/file.flac",<br/>"size": 23644000,<br/>"decision": "directplay",<br/>"selected": true,<br/>"Stream": [<br/>{<br/>"albumGain": "-12.94",<br/>"albumPeak": "1.000000",<br/>"albumRange": "4.751014",<br/>"audioChannelLayout": "stereo",<br/>"bitDepth": 16,<br/>"bitrate": 1014,<br/>"channels": 2,<br/>"codec": "flac",<br/>"displayTitle": "FLAC (Stereo)",<br/>"extendedDisplayTitle": "FLAC (Stereo)",<br/>"gain": "-12.94",<br/>"id": "352487",<br/>"index": 0,<br/>"loudness": "-5.94",<br/>"lra": "1.74",<br/>"peak": "1.000000",<br/>"samplingRate": 44100,<br/>"selected": true,<br/>"streamType": 2,<br/>"location": "direct"<br/>}<br/>]<br/>}<br/>]<br/>}<br/>] |
-| `User`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [*operations.User](../../models/operations/user.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `Player`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | [*operations.Player](../../models/operations/player.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `Session`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | [*operations.Session](../../models/operations/session.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Title`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | *string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | :heavy_check_mark:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The title of the item (e.g. “300” or “The Simpsons”)                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Type`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | *string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | :heavy_check_mark:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The type of the video item, such as `movie`, `episode`, or `clip`.                                                                                                                                                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `AbsoluteIndex`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, contains the disc number for a track on multi-disc albums.                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `AddedAt`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | *int64*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | :heavy_check_mark:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | In units of seconds since the epoch, returns the time at which the item was added to the library.                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Art`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, the URL for the background artwork for the item.                                                                                                                                                                                                                                                                                                                                                                                                                                          | /library/metadata/58683/art/1703239236                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `AudienceRating`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | **float32*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Some rating systems separate reviewer ratings from audience ratings                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `AudienceRatingImage`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | A URI representing the image to be shown with the audience rating (e.g. rottentomatoes://image.rating.spilled).                                                                                                                                                                                                                                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Autotag`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | [][components.Tag](../../models/components/tag.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Banner`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, the URL for a banner graphic for the item.                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `ChapterSource`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, indicates the source for the chapters in the media file. Can be media (the chapters were embedded in the media itself), agent (a metadata agent computed them), or mixed (a combination of the two).                                                                                                                                                                                                                                                                                      | media                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `ChildCount`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The number of child items associated with this media item.                                                                                                                                                                                                                                                                                                                                                                                                                                              | 1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `Composite`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, the URL for a composite image for descendent items (e.g. photo albums or playlists).                                                                                                                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `ContentRating`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | If known, the content rating (e.g. MPAA) for an item.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Country`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | [][components.Tag](../../models/components/tag.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Director`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | [][components.Tag](../../models/components/tag.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Duration`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, the duration for the item, in units of milliseconds.                                                                                                                                                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Filter`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | [][components.Filter](../../models/components/filter.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Typically only seen in metadata at a library's top level                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Genre`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [][components.Tag](../../models/components/tag.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `GrandparentArt`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The `art` of the grandparent                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `GrandparentGUID`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The GUID of the grandparent media item.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | plex://show/5d9c081b170e24001f2a7be4                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `GrandparentHero`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The `hero` of the grandparent                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `GrandparentKey`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The `key` of the grandparent                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `GrandparentRatingKey`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The `ratingKey` of the grandparent                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `GrandparentTheme`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The `theme` of the grandparent                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `GrandparentThumb`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The `thumb` of the grandparent                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `GrandparentTitle`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The `title` of the grandparent                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `GUID`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The globally unique identifier for the media item.                                                                                                                                                                                                                                                                                                                                                                                                                                                      | plex://movie/5d7768ba96b655001fdc0408                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `Guids`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [][components.ItemsGuids](../../models/components/itemsguids.md)                                                                                                                                                                                                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Hero`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, the URL for a hero image for the item.                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Image`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [][components.Image](../../models/components/image.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Index`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, this represents the episode number for episodes, season number for seasons, or track number for audio tracks.                                                                                                                                                                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Key`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | *string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | :heavy_check_mark:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The key at which the item's details can be fetched.  In many cases a metadata item may be passed without all the details (such as in a hub) and this key corresponds to the endpoint to fetch additional details.                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `LastViewedAt`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | **int64*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 1556281940                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `LeafCount`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | For shows and seasons, contains the number of total episodes.                                                                                                                                                                                                                                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Media`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [][components.Media](../../models/components/media.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `OriginallyAvailableAt`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [*types.Date](../../types/date.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, in the format YYYY-MM-DD [HH:MM:SS] (the hours/minutes/seconds part is not always present). The air date, or a higher resolution release date for an item, depending on type. For example, episodes usually have air date like 1979-08-10 (we don't use epoch seconds because media existed prior to 1970). In some cases, recorded over-the-air content has higher resolution air date which includes a time component. Albums and movies may have day-resolution release dates as well. | 2022-12-14                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `OriginalTitle`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, used to indicate an item's original title, e.g. a movie's foreign title.                                                                                                                                                                                                                                                                                                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `ParentGUID`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The GUID of the parent media item.                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | plex://show/5d9c081b170e24001f2a7be4                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `ParentHero`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The `hero` of the parent                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `ParentIndex`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The `index` of the parent                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `ParentKey`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The `key` of the parent                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `ParentRatingKey`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The `ratingKey` of the parent                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `ParentThumb`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The `thumb` of the parent                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `ParentTitle`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The `title` of the parent                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `PrimaryExtraKey`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Indicates that the item has a primary extra; for a movie, this is a trailer, and for a music track it is a music video. The URL points to the metadata details endpoint for the item.                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Prompt`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Prompt to give the user for this directory (such as `Search Movies`)                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Rating`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | **float32*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, the rating for the item. The exact meaning and representation depends on where the rating was sourced from.                                                                                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `RatingArray`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | [][components.Tag](../../models/components/tag.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `RatingCount`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Number of ratings under this metadata                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `RatingImage`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, indicates an image to be shown with the rating. This is passed back as a small set of defined URI values, e.g. rottentomatoes://image.rating.rotten.                                                                                                                                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `RatingKey`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | This is the opaque string to be passed into timeline, scrobble, and rating endpoints to identify them.  While it often appears to be numeric, this is not guaranteed.                                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Role`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | [][components.Tag](../../models/components/tag.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Search`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | **bool*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Indicates this is a search directory                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Secondary`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | **bool*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Used by old clients to provide nested menus allowing for primative (but structured) navigation.                                                                                                                                                                                                                                                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `SkipChildren`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | **bool*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When found on a show item, indicates that the children (seasons) should be skipped in favor of the grandchildren (episodes). Useful for mini-series, etc.                                                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `SkipParent`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | **bool*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present on an episode or track item, indicates parent should be skipped in favor of grandparent (show).                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Sort`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | [][components.Sort](../../models/components/sort.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                    | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Typically only seen in metadata at a library's top level                                                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Studio`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, the studio or label which produced an item (e.g. movie studio for movies, record label for albums).                                                                                                                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Subtype`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | The subtype of the video item, such as `photo` when the video item is in a photo library                                                                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Summary`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, the extended textual information about the item (e.g. movie plot, artist biography, album review).                                                                                                                                                                                                                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Tagline`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, a pithy one-liner about the item (usually only seen for movies).                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Theme`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, the URL for theme music for the item (usually only for TV shows).                                                                                                                                                                                                                                                                                                                                                                                                                         | /library/metadata/1/theme/1705636920                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `Thumb`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, the URL for the poster or thumbnail for the item. When available for types like movie, it will be the poster graphic, but fall-back to the extracted media thumbnail.                                                                                                                                                                                                                                                                                                                     | /library/metadata/58683/thumb/1703239236                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `TitleSort`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | **string*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Whene present, this is the string used for sorting the item. It's usually the title with any leading articles removed (e.g. “Simpsons”).                                                                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `UpdatedAt`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | **int64*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | In units of seconds since the epoch, returns the time at which the item was last changed (e.g. had its metadata updated).                                                                                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `UserRating`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | **float32*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When the user has rated an item, this contains the user rating                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `ViewCount`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When a users has completed watched or listened to an item, this attribute contains the number of consumptions.                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `ViewedLeafCount`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | For shows and seasons, contains the number of viewed episodes.                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `ViewOffset`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When a user is in the process of viewing or listening to this item, this attribute contains the current offset, in units of milliseconds.                                                                                                                                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Writer`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | [][components.Tag](../../models/components/tag.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Year`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | **int*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | When present, the year associated with the item's release (e.g. release year for a movie).                                                                                                                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `MetadataItem`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | [][components.Items](../../models/components/items.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `AdditionalProperties`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | map[string]*any*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |

docs/models/components/itemsguids.md

@@ -0,0 +1,8 @@
+# ItemsGuids
+
+
+## Fields
+
+| Field                                                                                                                                                                                                                            | Type                                                                                                                                                                                                                             | Required                                                                                                                                                                                                                         | Description                                                                                                                                                                                                                      | Example                                                                                                                                                                                                                          |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ID`                                                                                                                                                                                                                             | *string*                                                                                                                                                                                                                         | :heavy_check_mark:                                                                                                                                                                                                               | The unique identifier for the Guid. Can be prefixed with imdb://, tmdb://, tvdb://<br/>                                                                                                                                          | {<br/>"imdbExample": {<br/>"summary": "IMDB example",<br/>"value": "imdb://tt13015952"<br/>},<br/>"tmdbExample": {<br/>"summary": "TMDB example",<br/>"value": "tmdb://2434012"<br/>},<br/>"tvdbExample": {<br/>"summary": "TVDB example",<br/>"value": "tvdb://7945991"<br/>}<br/>} |

docs/models/components/librarysection.md

@@ -0,0 +1,28 @@
+# LibrarySection
+
+
+## Fields
+
+| Field                                                                                        | Type                                                                                         | Required                                                                                     | Description                                                                                  | Example                                                                                      |
+| -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| `Title`                                                                                      | **string*                                                                                    | :heavy_minus_sign:                                                                           | The title of the library                                                                     | Movies                                                                                       |
+| `Type`                                                                                       | [components.MediaTypeString](../../models/components/mediatypestring.md)                     | :heavy_check_mark:                                                                           | The type of media content in the Plex library. This can represent videos, music, or photos.<br/> | movie                                                                                        |
+| `Agent`                                                                                      | **string*                                                                                    | :heavy_minus_sign:                                                                           | N/A                                                                                          |                                                                                              |
+| `AllowSync`                                                                                  | **bool*                                                                                      | :heavy_minus_sign:                                                                           | N/A                                                                                          |                                                                                              |
+| `Art`                                                                                        | **string*                                                                                    | :heavy_minus_sign:                                                                           | N/A                                                                                          |                                                                                              |
+| `Composite`                                                                                  | **string*                                                                                    | :heavy_minus_sign:                                                                           | N/A                                                                                          |                                                                                              |
+| `Content`                                                                                    | **bool*                                                                                      | :heavy_minus_sign:                                                                           | N/A                                                                                          |                                                                                              |
+| `ContentChangedAt`                                                                           | **int64*                                                                                     | :heavy_minus_sign:                                                                           | N/A                                                                                          | 1556281940                                                                                   |
+| `CreatedAt`                                                                                  | **int64*                                                                                     | :heavy_minus_sign:                                                                           | N/A                                                                                          | 1556281940                                                                                   |
+| `Directory`                                                                                  | **bool*                                                                                      | :heavy_minus_sign:                                                                           | N/A                                                                                          |                                                                                              |
+| `Filters`                                                                                    | **bool*                                                                                      | :heavy_minus_sign:                                                                           | Indicates whether this section has filtering capabilities                                    |                                                                                              |
+| `Hidden`                                                                                     | **bool*                                                                                      | :heavy_minus_sign:                                                                           | N/A                                                                                          |                                                                                              |
+| `Key`                                                                                        | **string*                                                                                    | :heavy_minus_sign:                                                                           | N/A                                                                                          |                                                                                              |
+| `Language`                                                                                   | *string*                                                                                     | :heavy_check_mark:                                                                           | N/A                                                                                          |                                                                                              |
+| `UUID`                                                                                       | *string*                                                                                     | :heavy_check_mark:                                                                           | The universally unique identifier for the library.                                           | e69655a2-ef48-4aba-bb19-d3cc3401e7d6                                                         |
+| `Location`                                                                                   | [][components.LibrarySectionLocation](../../models/components/librarysectionlocation.md)     | :heavy_minus_sign:                                                                           | N/A                                                                                          |                                                                                              |
+| `Refreshing`                                                                                 | **bool*                                                                                      | :heavy_minus_sign:                                                                           | Indicates whether this library section is currently scanning                                 |                                                                                              |
+| `ScannedAt`                                                                                  | **int64*                                                                                     | :heavy_minus_sign:                                                                           | N/A                                                                                          | 1556281940                                                                                   |
+| `Scanner`                                                                                    | **string*                                                                                    | :heavy_minus_sign:                                                                           | N/A                                                                                          |                                                                                              |
+| `Thumb`                                                                                      | **string*                                                                                    | :heavy_minus_sign:                                                                           | N/A                                                                                          |                                                                                              |
+| `UpdatedAt`                                                                                  | **int64*                                                                                     | :heavy_minus_sign:                                                                           | N/A                                                                                          | 1556281940                                                                                   |

docs/models/components/librarysectionlocation.md

@@ -0,0 +1,11 @@
+# LibrarySectionLocation
+
+Represents a top-level location on disk where media in this library section is stored
+
+
+## Fields
+
+| Field                                           | Type                                            | Required                                        | Description                                     |
+| ----------------------------------------------- | ----------------------------------------------- | ----------------------------------------------- | ----------------------------------------------- |
+| `ID`                                            | **int64*                                        | :heavy_minus_sign:                              | N/A                                             |
+| `Path`                                          | *any*                                           | :heavy_minus_sign:                              | The path of where this directory exists on disk |

docs/models/components/librarysections.md

@@ -1,10 +1,10 @@
-# GetLibraryItemsResponseBody
+# LibrarySections
 
-The contents of the library by section and tag
+OK
 
 
 ## Fields
 
 | Field                                                                                                 | Type                                                                                                  | Required                                                                                              | Description                                                                                           |
 | ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
-| `MediaContainer`                                                                                      | [*operations.GetLibraryItemsMediaContainer](../../models/operations/getlibraryitemsmediacontainer.md) | :heavy_minus_sign:                                                                                    | N/A                                                                                                   |
+| `MediaContainer`                                                                                      | [*components.LibrarySectionsMediaContainer](../../models/components/librarysectionsmediacontainer.md) | :heavy_minus_sign:                                                                                    | N/A                                                                                                   |

docs/models/components/librarysectionsdirectory.md

@@ -0,0 +1,10 @@
+# LibrarySectionsDirectory
+
+
+## Fields
+
+| Field                                 | Type                                  | Required                              | Description                           |
+| ------------------------------------- | ------------------------------------- | ------------------------------------- | ------------------------------------- |
+| `Count`                               | **int64*                              | :heavy_minus_sign:                    | N/A                                   |
+| `Key`                                 | **string*                             | :heavy_minus_sign:                    | The key where this directory is found |
+| `Title`                               | **string*                             | :heavy_minus_sign:                    | N/A                                   |

docs/models/components/librarysectionsmediacontainer.md

@@ -0,0 +1,65 @@
+# LibrarySectionsMediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
+
+
+## Fields
+
+| Field                                                                                                                                    | Type                                                                                                                                     | Required                                                                                                                                 | Description                                                                                                                              | Example                                                                                                                                  |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                             | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `Offset`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/> |                                                                                                                                          |
+| `Size`                                                                                                                                   | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `TotalSize`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                     |                                                                                                                                          |
+| `AllowCameraUpload`                                                                                                                      | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `AllowChannelAccess`                                                                                                                     | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `AllowMediaDeletion`                                                                                                                     | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `AllowSharing`                                                                                                                           | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `AllowSync`                                                                                                                              | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `AllowTuners`                                                                                                                            | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `BackgroundProcessing`                                                                                                                   | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `Certificate`                                                                                                                            | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `CompanionProxy`                                                                                                                         | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `CountryCode`                                                                                                                            | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `Diagnostics`                                                                                                                            | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `EventStream`                                                                                                                            | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `FriendlyName`                                                                                                                           | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `HubSearch`                                                                                                                              | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `ItemClusters`                                                                                                                           | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `Livetv`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      | 7                                                                                                                                        |
+| `MachineIdentifier`                                                                                                                      | *any*                                                                                                                                    | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      | 0123456789abcdef0123456789abcdef012345678                                                                                                |
+| `MediaProviders`                                                                                                                         | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `Multiuser`                                                                                                                              | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `MusicAnalysis`                                                                                                                          | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      | 2                                                                                                                                        |
+| `MyPlex`                                                                                                                                 | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `MyPlexMappingState`                                                                                                                     | *any*                                                                                                                                    | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      | mapped                                                                                                                                   |
+| `MyPlexSigninState`                                                                                                                      | *any*                                                                                                                                    | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      | ok                                                                                                                                       |
+| `MyPlexSubscription`                                                                                                                     | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `MyPlexUsername`                                                                                                                         | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `OfflineTranscode`                                                                                                                       | *any*                                                                                                                                    | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      | 1                                                                                                                                        |
+| `OwnerFeatures`                                                                                                                          | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | A comma-separated list of features which are enabled for the server owner                                                                |                                                                                                                                          |
+| `Platform`                                                                                                                               | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `PlatformVersion`                                                                                                                        | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `PluginHost`                                                                                                                             | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `PushNotifications`                                                                                                                      | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `ReadOnlyLibraries`                                                                                                                      | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `StreamingBrainABRVersion`                                                                                                               | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `StreamingBrainVersion`                                                                                                                  | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `Sync`                                                                                                                                   | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `TranscoderActiveVideoSessions`                                                                                                          | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `TranscoderAudio`                                                                                                                        | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `TranscoderLyrics`                                                                                                                       | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `TranscoderPhoto`                                                                                                                        | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `TranscoderSubtitles`                                                                                                                    | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `TranscoderVideo`                                                                                                                        | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `TranscoderVideoBitrates`                                                                                                                | *any*                                                                                                                                    | :heavy_minus_sign:                                                                                                                       | The suggested video quality bitrates to present to the user                                                                              |                                                                                                                                          |
+| `TranscoderVideoQualities`                                                                                                               | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `TranscoderVideoResolutions`                                                                                                             | *any*                                                                                                                                    | :heavy_minus_sign:                                                                                                                       | The suggested video resolutions to the above quality bitrates                                                                            |                                                                                                                                          |
+| `UpdatedAt`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `Updater`                                                                                                                                | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `Version`                                                                                                                                | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `VoiceSearch`                                                                                                                            | **bool*                                                                                                                                  | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |
+| `Directory`                                                                                                                              | [][components.LibrarySectionsDirectory](../../models/components/librarysectionsdirectory.md)                                             | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |                                                                                                                                          |

docs/models/components/lineup.md

@@ -0,0 +1,12 @@
+# Lineup
+
+
+## Fields
+
+| Field                                                                                     | Type                                                                                      | Required                                                                                  | Description                                                                               |
+| ----------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `Title`                                                                                   | **string*                                                                                 | :heavy_minus_sign:                                                                        | N/A                                                                                       |
+| `Type`                                                                                    | **string*                                                                                 | :heavy_minus_sign:                                                                        | The type of this object (`lineup` in this case)                                           |
+| `LineupType`                                                                              | [*components.LineupType](../../models/components/lineuptype.md)                           | :heavy_minus_sign:                                                                        | - `-1`: N/A<br/>- `0`: Over the air<br/>- `1`: Cable<br/>- `2`: Satellite<br/>- `3`: IPTV<br/>- `4`: Virtual<br/> |
+| `Location`                                                                                | **string*                                                                                 | :heavy_minus_sign:                                                                        | N/A                                                                                       |
+| `UUID`                                                                                    | **string*                                                                                 | :heavy_minus_sign:                                                                        | The uuid of this lineup                                                                   |

docs/models/components/lineuptype.md

@@ -0,0 +1,21 @@
+# LineupType
+
+- `-1`: N/A
+- `0`: Over the air
+- `1`: Cable
+- `2`: Satellite
+- `3`: IPTV
+- `4`: Virtual
+
+
+
+## Values
+
+| Name               | Value              |
+| ------------------ | ------------------ |
+| `LineupTypeMinus1` | -1                 |
+| `LineupTypeZero`   | 0                  |
+| `LineupTypeOne`    | 1                  |
+| `LineupTypeTwo`    | 2                  |
+| `LineupTypeThree`  | 3                  |
+| `LineupTypeFour`   | 4                  |

docs/models/components/location.md

@@ -0,0 +1,10 @@
+# Location
+
+
+## Values
+
+| Name               | Value              |
+| ------------------ | ------------------ |
+| `LocationLan`      | lan                |
+| `LocationWan`      | wan                |
+| `LocationCellular` | cellular           |

docs/models/components/mailingliststatus.md

@@ -0,0 +1,12 @@
+# MailingListStatus
+
+Your current mailing list status
+
+
+## Values
+
+| Name                            | Value                           |
+| ------------------------------- | ------------------------------- |
+| `MailingListStatusActive`       | active                          |
+| `MailingListStatusUnsubscribed` | unsubscribed                    |
+| `MailingListStatusRemoved`      | removed                         |

docs/models/components/media.md

@@ -0,0 +1,29 @@
+# Media
+
+`Media` represents an one or more media files (parts) and is a child of a metadata item. There aren't necessarily any guaranteed attributes on media elements since the attributes will vary based on the type. The possible attributes are not documented here, but they typically have self-evident names. High-level media information that can be used for badging and flagging, such as `videoResolution` and codecs, is included on the media element.
+
+
+
+## Fields
+
+| Field                                                | Type                                                 | Required                                             | Description                                          | Example                                              |
+| ---------------------------------------------------- | ---------------------------------------------------- | ---------------------------------------------------- | ---------------------------------------------------- | ---------------------------------------------------- |
+| `AspectRatio`                                        | **float32*                                           | :heavy_minus_sign:                                   | N/A                                                  | 2.35                                                 |
+| `AudioChannels`                                      | **int*                                               | :heavy_minus_sign:                                   | N/A                                                  | 2                                                    |
+| `AudioCodec`                                         | **string*                                            | :heavy_minus_sign:                                   | N/A                                                  | aac                                                  |
+| `AudioProfile`                                       | **string*                                            | :heavy_minus_sign:                                   | N/A                                                  | lc                                                   |
+| `Bitrate`                                            | **int*                                               | :heavy_minus_sign:                                   | N/A                                                  | 5612                                                 |
+| `Container`                                          | **string*                                            | :heavy_minus_sign:                                   | N/A                                                  | mov                                                  |
+| `Duration`                                           | **int*                                               | :heavy_minus_sign:                                   | N/A                                                  | 150192                                               |
+| `Has64bitOffsets`                                    | **bool*                                              | :heavy_minus_sign:                                   | N/A                                                  | false                                                |
+| `HasVoiceActivity`                                   | **bool*                                              | :heavy_minus_sign:                                   | N/A                                                  | true                                                 |
+| `Height`                                             | **int*                                               | :heavy_minus_sign:                                   | N/A                                                  | 544                                                  |
+| `ID`                                                 | *int64*                                              | :heavy_check_mark:                                   | N/A                                                  | 1                                                    |
+| `OptimizedForStreaming`                              | **bool*                                              | :heavy_minus_sign:                                   | N/A                                                  | false                                                |
+| `Part`                                               | [][components.Part](../../models/components/part.md) | :heavy_minus_sign:                                   | N/A                                                  |                                                      |
+| `VideoCodec`                                         | **string*                                            | :heavy_minus_sign:                                   | N/A                                                  | h264                                                 |
+| `VideoFrameRate`                                     | **string*                                            | :heavy_minus_sign:                                   | N/A                                                  | 24p                                                  |
+| `VideoProfile`                                       | **string*                                            | :heavy_minus_sign:                                   | N/A                                                  | main                                                 |
+| `VideoResolution`                                    | **string*                                            | :heavy_minus_sign:                                   | N/A                                                  | 720                                                  |
+| `Width`                                              | **int*                                               | :heavy_minus_sign:                                   | N/A                                                  | 1280                                                 |
+| `AdditionalProperties`                               | map[string]*any*                                     | :heavy_minus_sign:                                   | N/A                                                  |                                                      |

docs/models/components/mediacontainer.md

@@ -0,0 +1,16 @@
+# MediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
+
+
+## Fields
+
+| Field                                                                                                                                    | Type                                                                                                                                     | Required                                                                                                                                 | Description                                                                                                                              |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                             | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `Offset`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/> |
+| `Size`                                                                                                                                   | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `TotalSize`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                     |

docs/models/components/mediacontainerwithartwork.md

@@ -0,0 +1,8 @@
+# MediaContainerWithArtwork
+
+
+## Fields
+
+| Field                                                                                                                     | Type                                                                                                                      | Required                                                                                                                  | Description                                                                                                               |
+| ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| `MediaContainer`                                                                                                          | [*components.MediaContainerWithArtworkMediaContainer](../../models/components/mediacontainerwithartworkmediacontainer.md) | :heavy_minus_sign:                                                                                                        | N/A                                                                                                                       |

docs/models/components/mediacontainerwithartworkmediacontainer.md

@@ -0,0 +1,17 @@
+# MediaContainerWithArtworkMediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
+
+
+## Fields
+
+| Field                                                                                                                                    | Type                                                                                                                                     | Required                                                                                                                                 | Description                                                                                                                              |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                             | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `Offset`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/> |
+| `Size`                                                                                                                                   | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `TotalSize`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                     |
+| `Metadata`                                                                                                                               | [][components.MediaContainerWithArtworkMetadata](../../models/components/mediacontainerwithartworkmetadata.md)                           | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |

docs/models/components/mediacontainerwithartworkmetadata.md

@@ -0,0 +1,11 @@
+# MediaContainerWithArtworkMetadata
+
+
+## Fields
+
+| Field                                                                                                 | Type                                                                                                  | Required                                                                                              | Description                                                                                           |
+| ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
+| `Title`                                                                                               | **string*                                                                                             | :heavy_minus_sign:                                                                                    | The title of the item                                                                                 |
+| `Type`                                                                                                | [*components.MediaContainerWithArtworkType](../../models/components/mediacontainerwithartworktype.md) | :heavy_minus_sign:                                                                                    | N/A                                                                                                   |
+| `Key`                                                                                                 | **string*                                                                                             | :heavy_minus_sign:                                                                                    | The path to the artwork                                                                               |
+| `AdditionalProperties`                                                                                | map[string]*any*                                                                                      | :heavy_minus_sign:                                                                                    | N/A                                                                                                   |

docs/models/components/mediacontainerwithartworktype.md

@@ -0,0 +1,8 @@
+# MediaContainerWithArtworkType
+
+
+## Values
+
+| Name                                 | Value                                |
+| ------------------------------------ | ------------------------------------ |
+| `MediaContainerWithArtworkTypeImage` | image                                |

docs/models/components/mediacontainerwithdecision.md

@@ -0,0 +1,13 @@
+# MediaContainerWithDecision
+
+`MediaContainer` is commonly found as the root of a response and is a pretty generic container. Common attributes include `identifier` and things related to paging (`offset`, `size`, `totalSize`).
+
+It is also common for a `MediaContainer` to contain attributes "hoisted" from its children. If every element in the container would have had the same attribute, then that attribute can be present on the container instead of being repeated on every element. For example, an album's list of tracks might include `parentTitle` on the container since all of the tracks have the same album title. A container may have a `source` attribute when all of the items came from the same source. Generally speaking, when looking for an attribute on an item, if the attribute wasn't found then the container should be checked for that attribute as well.
+
+
+
+## Fields
+
+| Field                                                                                                                       | Type                                                                                                                        | Required                                                                                                                    | Description                                                                                                                 |
+| --------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| `MediaContainer`                                                                                                            | [*components.MediaContainerWithDecisionMediaContainer](../../models/components/mediacontainerwithdecisionmediacontainer.md) | :heavy_minus_sign:                                                                                                          | N/A                                                                                                                         |

docs/models/components/mediacontainerwithdecisiondecision.md

@@ -0,0 +1,13 @@
+# MediaContainerWithDecisionDecision
+
+
+## Values
+
+| Name                                            | Value                                           |
+| ----------------------------------------------- | ----------------------------------------------- |
+| `MediaContainerWithDecisionDecisionCopy`        | copy                                            |
+| `MediaContainerWithDecisionDecisionTranscode`   | transcode                                       |
+| `MediaContainerWithDecisionDecisionBurn`        | burn                                            |
+| `MediaContainerWithDecisionDecisionUnavailable` | unavailable                                     |
+| `MediaContainerWithDecisionDecisionIgnore`      | ignore                                          |
+| `MediaContainerWithDecisionDecisionNone`        | none                                            |

docs/models/components/mediacontainerwithdecisionguids.md

@@ -0,0 +1,8 @@
+# MediaContainerWithDecisionGuids
+
+
+## Fields
+
+| Field                                                                                                                                                                                                                            | Type                                                                                                                                                                                                                             | Required                                                                                                                                                                                                                         | Description                                                                                                                                                                                                                      | Example                                                                                                                                                                                                                          |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ID`                                                                                                                                                                                                                             | *string*                                                                                                                                                                                                                         | :heavy_check_mark:                                                                                                                                                                                                               | The unique identifier for the Guid. Can be prefixed with imdb://, tmdb://, tvdb://<br/>                                                                                                                                          | {<br/>"imdbExample": {<br/>"summary": "IMDB example",<br/>"value": "imdb://tt13015952"<br/>},<br/>"tmdbExample": {<br/>"summary": "TMDB example",<br/>"value": "tmdb://2434012"<br/>},<br/>"tvdbExample": {<br/>"summary": "TVDB example",<br/>"value": "tvdb://7945991"<br/>}<br/>} |

docs/models/components/mediacontainerwithdecisionlocation.md

@@ -0,0 +1,15 @@
+# MediaContainerWithDecisionLocation
+
+
+## Values
+
+| Name                                              | Value                                             |
+| ------------------------------------------------- | ------------------------------------------------- |
+| `MediaContainerWithDecisionLocationDirect`        | direct                                            |
+| `MediaContainerWithDecisionLocationSidecarSubs`   | sidecar-subs                                      |
+| `MediaContainerWithDecisionLocationSegmentsVideo` | segments-video                                    |
+| `MediaContainerWithDecisionLocationSegmentsAudio` | segments-audio                                    |
+| `MediaContainerWithDecisionLocationSegmentsAv`    | segments-av                                       |
+| `MediaContainerWithDecisionLocationSegmentsSubs`  | segments-subs                                     |
+| `MediaContainerWithDecisionLocationEmbedded`      | embedded                                          |
+| `MediaContainerWithDecisionLocationSidecar`       | sidecar                                           |

docs/models/components/mediacontainerwithdecisionmedia.md

@@ -0,0 +1,32 @@
+# MediaContainerWithDecisionMedia
+
+`Media` represents an one or more media files (parts) and is a child of a metadata item. There aren't necessarily any guaranteed attributes on media elements since the attributes will vary based on the type. The possible attributes are not documented here, but they typically have self-evident names. High-level media information that can be used for badging and flagging, such as `videoResolution` and codecs, is included on the media element.
+
+
+
+## Fields
+
+| Field                                                                                                    | Type                                                                                                     | Required                                                                                                 | Description                                                                                              | Example                                                                                                  |
+| -------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
+| `AspectRatio`                                                                                            | **float32*                                                                                               | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | 2.35                                                                                                     |
+| `AudioChannels`                                                                                          | **int*                                                                                                   | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | 2                                                                                                        |
+| `AudioCodec`                                                                                             | **string*                                                                                                | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | aac                                                                                                      |
+| `AudioProfile`                                                                                           | **string*                                                                                                | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | lc                                                                                                       |
+| `Bitrate`                                                                                                | **int*                                                                                                   | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | 5612                                                                                                     |
+| `Container`                                                                                              | **string*                                                                                                | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | mov                                                                                                      |
+| `Duration`                                                                                               | **int*                                                                                                   | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | 150192                                                                                                   |
+| `Has64bitOffsets`                                                                                        | **bool*                                                                                                  | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | false                                                                                                    |
+| `HasVoiceActivity`                                                                                       | **bool*                                                                                                  | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | true                                                                                                     |
+| `Height`                                                                                                 | **int*                                                                                                   | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | 544                                                                                                      |
+| `ID`                                                                                                     | *int64*                                                                                                  | :heavy_check_mark:                                                                                       | N/A                                                                                                      | 1                                                                                                        |
+| `OptimizedForStreaming`                                                                                  | **bool*                                                                                                  | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | false                                                                                                    |
+| `Part`                                                                                                   | [][components.MediaContainerWithDecisionPart](../../models/components/mediacontainerwithdecisionpart.md) | :heavy_minus_sign:                                                                                       | N/A                                                                                                      |                                                                                                          |
+| `VideoCodec`                                                                                             | **string*                                                                                                | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | h264                                                                                                     |
+| `VideoFrameRate`                                                                                         | **string*                                                                                                | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | 24p                                                                                                      |
+| `VideoProfile`                                                                                           | **string*                                                                                                | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | main                                                                                                     |
+| `VideoResolution`                                                                                        | **string*                                                                                                | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | 720                                                                                                      |
+| `Width`                                                                                                  | **int*                                                                                                   | :heavy_minus_sign:                                                                                       | N/A                                                                                                      | 1280                                                                                                     |
+| `Abr`                                                                                                    | **bool*                                                                                                  | :heavy_minus_sign:                                                                                       | N/A                                                                                                      |                                                                                                          |
+| `ResourceSession`                                                                                        | **string*                                                                                                | :heavy_minus_sign:                                                                                       | N/A                                                                                                      |                                                                                                          |
+| `Selected`                                                                                               | **bool*                                                                                                  | :heavy_minus_sign:                                                                                       | N/A                                                                                                      |                                                                                                          |
+| `AdditionalProperties`                                                                                   | map[string]*any*                                                                                         | :heavy_minus_sign:                                                                                       | N/A                                                                                                      |                                                                                                          |

docs/models/components/mediacontainerwithdecisionmediacontainer.md

@@ -1,11 +1,26 @@
-# AddPlaylistContentsMediaContainer
+# MediaContainerWithDecisionMediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
 
 
 ## Fields
 
-| Field                                                                                                                                                                                                                                                                                                                                                                                                      | Type                                                                                                                                                                                                                                                                                                                                                                                                       | Required                                                                                                                                                                                                                                                                                                                                                                                                   | Description                                                                                                                                                                                                                                                                                                                                                                                                | Example                                                                                                                                                                                                                                                                                                                                                                                                    |
-| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Size`                                                                                                                                                                                                                                                                                                                                                                                                     | **int*                                                                                                                                                                                                                                                                                                                                                                                                     | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                         | N/A                                                                                                                                                                                                                                                                                                                                                                                                        | 1                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `LeafCountAdded`                                                                                                                                                                                                                                                                                                                                                                                           | **int*                                                                                                                                                                                                                                                                                                                                                                                                     | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                         | N/A                                                                                                                                                                                                                                                                                                                                                                                                        | 1                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `LeafCountRequested`                                                                                                                                                                                                                                                                                                                                                                                       | **int*                                                                                                                                                                                                                                                                                                                                                                                                     | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                         | N/A                                                                                                                                                                                                                                                                                                                                                                                                        | 1                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `Metadata`                                                                                                                                                                                                                                                                                                                                                                                                 | [][operations.AddPlaylistContentsMetadata](../../models/operations/addplaylistcontentsmetadata.md)                                                                                                                                                                                                                                                                                                         | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                                                                                         | N/A                                                                                                                                                                                                                                                                                                                                                                                                        | [<br/>{<br/>"ratingKey": "94",<br/>"key": "/playlists/94/items",<br/>"guid": "com.plexapp.agents.none://972e3047-83d6-4848-a000-261f0af26ba2",<br/>"type": "playlist",<br/>"title": "A great playlist",<br/>"summary": "One of my great playlists",<br/>"smart": false,<br/>"playlistType": "video",<br/>"composite": "/playlists/94/composite/1705800070",<br/>"duration": 423000,<br/>"leafCount": 3,<br/>"addedAt": 1705716458,<br/>"updatedAt": 1705800070<br/>}<br/>] |
+| Field                                                                                                                                                                                                          | Type                                                                                                                                                                                                           | Required                                                                                                                                                                                                       | Description                                                                                                                                                                                                    |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                                                                                                   | **string*                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                             | N/A                                                                                                                                                                                                            |
+| `Offset`                                                                                                                                                                                                       | **int64*                                                                                                                                                                                                       | :heavy_minus_sign:                                                                                                                                                                                             | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/>                                                                   |
+| `Size`                                                                                                                                                                                                         | **int64*                                                                                                                                                                                                       | :heavy_minus_sign:                                                                                                                                                                                             | N/A                                                                                                                                                                                                            |
+| `TotalSize`                                                                                                                                                                                                    | **int64*                                                                                                                                                                                                       | :heavy_minus_sign:                                                                                                                                                                                             | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                                                                                           |
+| `AvailableBandwidth`                                                                                                                                                                                           | **int64*                                                                                                                                                                                                       | :heavy_minus_sign:                                                                                                                                                                                             | The maximum available bitrate when the decision was rendered.                                                                                                                                                  |
+| `DirectPlayDecisionCode`                                                                                                                                                                                       | **int64*                                                                                                                                                                                                       | :heavy_minus_sign:                                                                                                                                                                                             | N/A                                                                                                                                                                                                            |
+| `DirectPlayDecisionText`                                                                                                                                                                                       | **string*                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                             | N/A                                                                                                                                                                                                            |
+| `GeneralDecisionCode`                                                                                                                                                                                          | **int64*                                                                                                                                                                                                       | :heavy_minus_sign:                                                                                                                                                                                             | The overall decision. 1xxx are playback can succeed, 2xxx are a general error (such as insufficient bandwidth), 3xxx are errors in direct play, and 4xxx are errors in transcodes. Same codes are used in all. |
+| `GeneralDecisionText`                                                                                                                                                                                          | **string*                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                             | N/A                                                                                                                                                                                                            |
+| `MdeDecisionCode`                                                                                                                                                                                              | **int64*                                                                                                                                                                                                       | :heavy_minus_sign:                                                                                                                                                                                             | The code indicating the status of evaluation of playback when client indicates `hasMDE=1`                                                                                                                      |
+| `MdeDecisionText`                                                                                                                                                                                              | **string*                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                             | Descriptive text for the above code                                                                                                                                                                            |
+| `Metadata`                                                                                                                                                                                                     | [][components.MediaContainerWithDecisionMetadata](../../models/components/mediacontainerwithdecisionmetadata.md)                                                                                               | :heavy_minus_sign:                                                                                                                                                                                             | N/A                                                                                                                                                                                                            |
+| `TranscodeDecisionCode`                                                                                                                                                                                        | **int64*                                                                                                                                                                                                       | :heavy_minus_sign:                                                                                                                                                                                             | N/A                                                                                                                                                                                                            |
+| `TranscodeDecisionText`                                                                                                                                                                                        | **string*                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                             | N/A                                                                                                                                                                                                            |

docs/models/components/mediacontainerwithdecisionpart.md

@@ -0,0 +1,27 @@
+# MediaContainerWithDecisionPart
+
+`Part` represents a particular file or "part" of a media item. The part is the playable unit of the media hierarchy. Suppose that a movie library contains a movie that is broken up into files, reminiscent of a movie split across two BDs. The metadata item represents information about the movie, the media item represents this instance of the movie at this resolution and quality, and the part items represent the two playable files.  If another media were added which contained the joining of these two parts transcoded down to a lower resolution, then this metadata would contain 2 medias, one with 2 parts and one with 1 part.
+
+
+
+## Fields
+
+| Field                                                                                                        | Type                                                                                                         | Required                                                                                                     | Description                                                                                                  | Example                                                                                                      |
+| ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------ |
+| `Accessible`                                                                                                 | **bool*                                                                                                      | :heavy_minus_sign:                                                                                           | Indicates if the part is accessible.                                                                         | true                                                                                                         |
+| `AudioProfile`                                                                                               | **string*                                                                                                    | :heavy_minus_sign:                                                                                           | N/A                                                                                                          | lc                                                                                                           |
+| `Container`                                                                                                  | **string*                                                                                                    | :heavy_minus_sign:                                                                                           | The container of the media file, such as `mp4` or `mkv`                                                      | mov                                                                                                          |
+| `Duration`                                                                                                   | **int*                                                                                                       | :heavy_minus_sign:                                                                                           | The duration of the media item, in milliseconds                                                              | 150192                                                                                                       |
+| `Exists`                                                                                                     | **bool*                                                                                                      | :heavy_minus_sign:                                                                                           | Indicates if the part exists.                                                                                | true                                                                                                         |
+| `File`                                                                                                       | **string*                                                                                                    | :heavy_minus_sign:                                                                                           | The local file path at which the part is stored on the server                                                | /home/schuyler/Videos/Trailers/Cloud Atlas (2012).mov                                                        |
+| `Has64bitOffsets`                                                                                            | **bool*                                                                                                      | :heavy_minus_sign:                                                                                           | N/A                                                                                                          | false                                                                                                        |
+| `ID`                                                                                                         | *int64*                                                                                                      | :heavy_check_mark:                                                                                           | N/A                                                                                                          | 1                                                                                                            |
+| `Indexes`                                                                                                    | **string*                                                                                                    | :heavy_minus_sign:                                                                                           | N/A                                                                                                          | sd                                                                                                           |
+| `Key`                                                                                                        | *string*                                                                                                     | :heavy_check_mark:                                                                                           | The key from which the media can be streamed                                                                 | /library/parts/1/1531779263/file.mov                                                                         |
+| `OptimizedForStreaming`                                                                                      | **bool*                                                                                                      | :heavy_minus_sign:                                                                                           | N/A                                                                                                          | false                                                                                                        |
+| `Size`                                                                                                       | **int64*                                                                                                     | :heavy_minus_sign:                                                                                           | The size of the media, in bytes                                                                              | 105355654                                                                                                    |
+| `Stream`                                                                                                     | [][components.MediaContainerWithDecisionStream](../../models/components/mediacontainerwithdecisionstream.md) | :heavy_minus_sign:                                                                                           | N/A                                                                                                          |                                                                                                              |
+| `VideoProfile`                                                                                               | **string*                                                                                                    | :heavy_minus_sign:                                                                                           | N/A                                                                                                          | main                                                                                                         |
+| `Decision`                                                                                                   | [*components.Decision](../../models/components/decision.md)                                                  | :heavy_minus_sign:                                                                                           | N/A                                                                                                          |                                                                                                              |
+| `Selected`                                                                                                   | **bool*                                                                                                      | :heavy_minus_sign:                                                                                           | N/A                                                                                                          |                                                                                                              |
+| `AdditionalProperties`                                                                                       | map[string]*any*                                                                                             | :heavy_minus_sign:                                                                                           | N/A                                                                                                          |                                                                                                              |

docs/models/components/mediacontainerwithdecisionstream.md

@@ -0,0 +1,65 @@
+# MediaContainerWithDecisionStream
+
+`Stream` represents a particular stream from a media item, such as the video stream, audio stream, or subtitle stream. The stream may either be part of the file represented by the parent `Part` or, especially for subtitles, an external file. The stream contains more detailed information about the specific stream. For example, a video may include the `aspectRatio` at the `Media` level, but detailed information about the video stream like the color space will be included on the `Stream` for the video stream.  Note that photos do not have streams (mostly as an optimization).
+
+
+
+## Fields
+
+| Field                                                                                                           | Type                                                                                                            | Required                                                                                                        | Description                                                                                                     | Example                                                                                                         |
+| --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| `Default`                                                                                                       | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | Indicates if this stream is default.                                                                            | true                                                                                                            |
+| `AudioChannelLayout`                                                                                            | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Audio channel layout.                                                                                           | 5.1(side)                                                                                                       |
+| `Channels`                                                                                                      | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Number of audio channels (for audio streams).                                                                   | 6                                                                                                               |
+| `BitDepth`                                                                                                      | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Bit depth of the video stream.                                                                                  | 10                                                                                                              |
+| `DOVIBLCompatID`                                                                                                | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Dolby Vision BL compatibility ID.                                                                               | 1                                                                                                               |
+| `DOVIBLPresent`                                                                                                 | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | Indicates if Dolby Vision BL is present.                                                                        | true                                                                                                            |
+| `DOVIELPresent`                                                                                                 | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | Indicates if Dolby Vision EL is present.                                                                        | false                                                                                                           |
+| `DOVILevel`                                                                                                     | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Dolby Vision level.                                                                                             | 6                                                                                                               |
+| `DOVIPresent`                                                                                                   | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | Indicates if Dolby Vision is present.                                                                           | true                                                                                                            |
+| `DOVIProfile`                                                                                                   | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Dolby Vision profile.                                                                                           | 8                                                                                                               |
+| `DOVIRPUPresent`                                                                                                | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | Indicates if Dolby Vision RPU is present.                                                                       | true                                                                                                            |
+| `DOVIVersion`                                                                                                   | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Dolby Vision version.                                                                                           | 1.0                                                                                                             |
+| `Bitrate`                                                                                                       | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Bitrate of the stream.                                                                                          | 24743                                                                                                           |
+| `CanAutoSync`                                                                                                   | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | Indicates if the stream can auto-sync.                                                                          | false                                                                                                           |
+| `ChromaLocation`                                                                                                | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Chroma sample location.                                                                                         | topleft                                                                                                         |
+| `ChromaSubsampling`                                                                                             | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Chroma subsampling format.                                                                                      | 4:2:0                                                                                                           |
+| `CodedHeight`                                                                                                   | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Coded video height.                                                                                             | 1608                                                                                                            |
+| `CodedWidth`                                                                                                    | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Coded video width.                                                                                              | 3840                                                                                                            |
+| `ClosedCaptions`                                                                                                | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | N/A                                                                                                             | true                                                                                                            |
+| `Codec`                                                                                                         | *string*                                                                                                        | :heavy_check_mark:                                                                                              | Codec used by the stream.                                                                                       | hevc                                                                                                            |
+| `ColorPrimaries`                                                                                                | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Color primaries used.                                                                                           | bt2020                                                                                                          |
+| `ColorRange`                                                                                                    | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Color range (e.g., tv).                                                                                         | tv                                                                                                              |
+| `ColorSpace`                                                                                                    | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Color space.                                                                                                    | bt2020nc                                                                                                        |
+| `ColorTrc`                                                                                                      | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Color transfer characteristics.                                                                                 | smpte2084                                                                                                       |
+| `DisplayTitle`                                                                                                  | *string*                                                                                                        | :heavy_check_mark:                                                                                              | Display title for the stream.                                                                                   | 4K DoVi/HDR10 (HEVC Main 10)                                                                                    |
+| `ExtendedDisplayTitle`                                                                                          | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Extended display title for the stream.                                                                          | 4K DoVi/HDR10 (HEVC Main 10)                                                                                    |
+| `FrameRate`                                                                                                     | **float32*                                                                                                      | :heavy_minus_sign:                                                                                              | Frame rate of the stream.                                                                                       | 23.976                                                                                                          |
+| `HasScalingMatrix`                                                                                              | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | N/A                                                                                                             | false                                                                                                           |
+| `Height`                                                                                                        | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Height of the video stream.                                                                                     | 1602                                                                                                            |
+| `ID`                                                                                                            | *int*                                                                                                           | :heavy_check_mark:                                                                                              | Unique stream identifier.                                                                                       | 1002625                                                                                                         |
+| `Index`                                                                                                         | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Index of the stream.                                                                                            | 0                                                                                                               |
+| `Key`                                                                                                           | *string*                                                                                                        | :heavy_check_mark:                                                                                              | Key to access this stream part.                                                                                 | /library/streams/216389                                                                                         |
+| `Language`                                                                                                      | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Language of the stream.                                                                                         | English                                                                                                         |
+| `LanguageCode`                                                                                                  | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | ISO language code.                                                                                              | eng                                                                                                             |
+| `LanguageTag`                                                                                                   | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Language tag (e.g., en).                                                                                        | en                                                                                                              |
+| `Format`                                                                                                        | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Format of the stream (e.g., srt).                                                                               | srt                                                                                                             |
+| `HeaderCompression`                                                                                             | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | Indicates whether header compression is enabled.                                                                | true                                                                                                            |
+| `Level`                                                                                                         | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Video level.                                                                                                    | 150                                                                                                             |
+| `Original`                                                                                                      | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | Indicates if this is the original stream.                                                                       | true                                                                                                            |
+| `Profile`                                                                                                       | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Video profile.                                                                                                  | main 10                                                                                                         |
+| `RefFrames`                                                                                                     | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Number of reference frames.                                                                                     | 1                                                                                                               |
+| `SamplingRate`                                                                                                  | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Sampling rate for the audio stream.                                                                             | 48000                                                                                                           |
+| `ScanType`                                                                                                      | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | N/A                                                                                                             | progressive                                                                                                     |
+| `EmbeddedInVideo`                                                                                               | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | N/A                                                                                                             | progressive                                                                                                     |
+| `Selected`                                                                                                      | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | Indicates if this stream is selected (applicable for audio streams).                                            | true                                                                                                            |
+| `Forced`                                                                                                        | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | N/A                                                                                                             | true                                                                                                            |
+| `HearingImpaired`                                                                                               | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | Indicates if the stream is for the hearing impaired.                                                            | true                                                                                                            |
+| `Dub`                                                                                                           | **bool*                                                                                                         | :heavy_minus_sign:                                                                                              | Indicates if the stream is a dub.                                                                               | true                                                                                                            |
+| `Title`                                                                                                         | **string*                                                                                                       | :heavy_minus_sign:                                                                                              | Optional title for the stream (e.g., language variant).                                                         | SDH                                                                                                             |
+| `StreamIdentifier`                                                                                              | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | N/A                                                                                                             | 1                                                                                                               |
+| `StreamType`                                                                                                    | *int64*                                                                                                         | :heavy_check_mark:                                                                                              | Stream type:<br/>  - VIDEO = 1<br/>  - AUDIO = 2<br/>  - SUBTITLE = 3<br/>                                      |                                                                                                                 |
+| `Width`                                                                                                         | **int*                                                                                                          | :heavy_minus_sign:                                                                                              | Width of the video stream.                                                                                      | 3840                                                                                                            |
+| `Decision`                                                                                                      | [*components.MediaContainerWithDecisionDecision](../../models/components/mediacontainerwithdecisiondecision.md) | :heavy_minus_sign:                                                                                              | N/A                                                                                                             |                                                                                                                 |
+| `Location`                                                                                                      | [*components.MediaContainerWithDecisionLocation](../../models/components/mediacontainerwithdecisionlocation.md) | :heavy_minus_sign:                                                                                              | N/A                                                                                                             |                                                                                                                 |
+| `AdditionalProperties`                                                                                          | map[string]*any*                                                                                                | :heavy_minus_sign:                                                                                              | N/A                                                                                                             |                                                                                                                 |

docs/models/components/mediacontainerwithdevice.md

@@ -0,0 +1,8 @@
+# MediaContainerWithDevice
+
+
+## Fields
+
+| Field                                                                                                                   | Type                                                                                                                    | Required                                                                                                                | Description                                                                                                             |
+| ----------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `MediaContainer`                                                                                                        | [*components.MediaContainerWithDeviceMediaContainer](../../models/components/mediacontainerwithdevicemediacontainer.md) | :heavy_minus_sign:                                                                                                      | N/A                                                                                                                     |

docs/models/components/mediacontainerwithdevicedevice.md

@@ -0,0 +1,20 @@
+# MediaContainerWithDeviceDevice
+
+
+## Fields
+
+| Field                                                                    | Type                                                                     | Required                                                                 | Description                                                              |
+| ------------------------------------------------------------------------ | ------------------------------------------------------------------------ | ------------------------------------------------------------------------ | ------------------------------------------------------------------------ |
+| `ChannelMapping`                                                         | [][components.ChannelMapping](../../models/components/channelmapping.md) | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Key`                                                                    | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `LastSeenAt`                                                             | **int64*                                                                 | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Make`                                                                   | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Model`                                                                  | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `ModelNumber`                                                            | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Protocol`                                                               | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Sources`                                                                | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `State`                                                                  | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Status`                                                                 | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `Tuners`                                                                 | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `URI`                                                                    | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |
+| `UUID`                                                                   | **string*                                                                | :heavy_minus_sign:                                                       | N/A                                                                      |

docs/models/components/mediacontainerwithdevicemediacontainer.md

@@ -0,0 +1,17 @@
+# MediaContainerWithDeviceMediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
+
+
+## Fields
+
+| Field                                                                                                                                    | Type                                                                                                                                     | Required                                                                                                                                 | Description                                                                                                                              |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                             | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `Offset`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/> |
+| `Size`                                                                                                                                   | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `TotalSize`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                     |
+| `Device`                                                                                                                                 | [][components.MediaContainerWithDeviceDevice](../../models/components/mediacontainerwithdevicedevice.md)                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |

docs/models/components/mediacontainerwithdirectory.md

@@ -0,0 +1,8 @@
+# MediaContainerWithDirectory
+
+
+## Fields
+
+| Field                                                                                                                         | Type                                                                                                                          | Required                                                                                                                      | Description                                                                                                                   |
+| ----------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| `MediaContainer`                                                                                                              | [*components.MediaContainerWithDirectoryMediaContainer](../../models/components/mediacontainerwithdirectorymediacontainer.md) | :heavy_minus_sign:                                                                                                            | N/A                                                                                                                           |

docs/models/components/mediacontainerwithdirectorymediacontainer.md

@@ -0,0 +1,17 @@
+# MediaContainerWithDirectoryMediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
+
+
+## Fields
+
+| Field                                                                                                                                    | Type                                                                                                                                     | Required                                                                                                                                 | Description                                                                                                                              |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                             | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `Offset`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/> |
+| `Size`                                                                                                                                   | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `TotalSize`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                     |
+| `Directory`                                                                                                                              | [][components.Directory](../../models/components/directory.md)                                                                           | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |

docs/models/components/mediacontainerwithhubs.md

@@ -0,0 +1,10 @@
+# MediaContainerWithHubs
+
+OK
+
+
+## Fields
+
+| Field                                                                                                               | Type                                                                                                                | Required                                                                                                            | Description                                                                                                         |
+| ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
+| `MediaContainer`                                                                                                    | [*components.MediaContainerWithHubsMediaContainer](../../models/components/mediacontainerwithhubsmediacontainer.md) | :heavy_minus_sign:                                                                                                  | N/A                                                                                                                 |

docs/models/components/mediacontainerwithhubsmediacontainer.md

@@ -0,0 +1,17 @@
+# MediaContainerWithHubsMediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
+
+
+## Fields
+
+| Field                                                                                                                                    | Type                                                                                                                                     | Required                                                                                                                                 | Description                                                                                                                              |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                             | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `Offset`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/> |
+| `Size`                                                                                                                                   | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `TotalSize`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                     |
+| `Hub`                                                                                                                                    | [][components.Hub](../../models/components/hub.md)                                                                                       | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |

docs/models/components/mediacontainerwithlineup.md

@@ -0,0 +1,8 @@
+# MediaContainerWithLineup
+
+
+## Fields
+
+| Field                                                                                                                   | Type                                                                                                                    | Required                                                                                                                | Description                                                                                                             |
+| ----------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `MediaContainer`                                                                                                        | [*components.MediaContainerWithLineupMediaContainer](../../models/components/mediacontainerwithlineupmediacontainer.md) | :heavy_minus_sign:                                                                                                      | N/A                                                                                                                     |

docs/models/components/mediacontainerwithlineupmediacontainer.md

@@ -0,0 +1,18 @@
+# MediaContainerWithLineupMediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
+
+
+## Fields
+
+| Field                                                                                                                                    | Type                                                                                                                                     | Required                                                                                                                                 | Description                                                                                                                              |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                             | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `Offset`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/> |
+| `Size`                                                                                                                                   | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `TotalSize`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                     |
+| `Lineup`                                                                                                                                 | [][components.Lineup](../../models/components/lineup.md)                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `UUID`                                                                                                                                   | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | The UUID of this set lineups                                                                                                             |

docs/models/components/mediacontainerwithmetadata.md

@@ -0,0 +1,8 @@
+# MediaContainerWithMetadata
+
+
+## Fields
+
+| Field                                                                                                                       | Type                                                                                                                        | Required                                                                                                                    | Description                                                                                                                 |
+| --------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| `MediaContainer`                                                                                                            | [*components.MediaContainerWithMetadataMediaContainer](../../models/components/mediacontainerwithmetadatamediacontainer.md) | :heavy_minus_sign:                                                                                                          | N/A                                                                                                                         |

docs/models/components/mediacontainerwithmetadatamediacontainer.md

@@ -0,0 +1,17 @@
+# MediaContainerWithMetadataMediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
+
+
+## Fields
+
+| Field                                                                                                                                    | Type                                                                                                                                     | Required                                                                                                                                 | Description                                                                                                                              |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                             | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `Offset`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/> |
+| `Size`                                                                                                                                   | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `TotalSize`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                     |
+| `Metadata`                                                                                                                               | [][components.Metadata](../../models/components/metadata.md)                                                                             | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |

docs/models/components/mediacontainerwithnestedmetadata.md

@@ -0,0 +1,8 @@
+# MediaContainerWithNestedMetadata
+
+
+## Fields
+
+| Field                                                                                                                                   | Type                                                                                                                                    | Required                                                                                                                                | Description                                                                                                                             |
+| --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| `MediaContainer`                                                                                                                        | [*components.MediaContainerWithNestedMetadataMediaContainer](../../models/components/mediacontainerwithnestedmetadatamediacontainer.md) | :heavy_minus_sign:                                                                                                                      | N/A                                                                                                                                     |

docs/models/components/mediacontainerwithnestedmetadataguids.md

@@ -0,0 +1,8 @@
+# MediaContainerWithNestedMetadataGuids
+
+
+## Fields
+
+| Field                                                                                                                                                                                                                            | Type                                                                                                                                                                                                                             | Required                                                                                                                                                                                                                         | Description                                                                                                                                                                                                                      | Example                                                                                                                                                                                                                          |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ID`                                                                                                                                                                                                                             | *string*                                                                                                                                                                                                                         | :heavy_check_mark:                                                                                                                                                                                                               | The unique identifier for the Guid. Can be prefixed with imdb://, tmdb://, tvdb://<br/>                                                                                                                                          | {<br/>"imdbExample": {<br/>"summary": "IMDB example",<br/>"value": "imdb://tt13015952"<br/>},<br/>"tmdbExample": {<br/>"summary": "TMDB example",<br/>"value": "tmdb://2434012"<br/>},<br/>"tvdbExample": {<br/>"summary": "TVDB example",<br/>"value": "tvdb://7945991"<br/>}<br/>} |

docs/models/components/mediacontainerwithnestedmetadatamediacontainer.md

@@ -0,0 +1,17 @@
+# MediaContainerWithNestedMetadataMediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
+
+
+## Fields
+
+| Field                                                                                                                                    | Type                                                                                                                                     | Required                                                                                                                                 | Description                                                                                                                              |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                             | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `Offset`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/> |
+| `Size`                                                                                                                                   | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `TotalSize`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                     |
+| `MetadataItem`                                                                                                                           | [][components.MetadataItem](../../models/components/metadataitem.md)                                                                     | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |

docs/models/components/mediacontainerwithplaylistmetadata.md

@@ -0,0 +1,8 @@
+# MediaContainerWithPlaylistMetadata
+
+
+## Fields
+
+| Field                                                                                                                                       | Type                                                                                                                                        | Required                                                                                                                                    | Description                                                                                                                                 |
+| ------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| `MediaContainer`                                                                                                                            | [*components.MediaContainerWithPlaylistMetadataMediaContainer](../../models/components/mediacontainerwithplaylistmetadatamediacontainer.md) | :heavy_minus_sign:                                                                                                                          | N/A                                                                                                                                         |

docs/models/components/mediacontainerwithplaylistmetadataguids.md

@@ -0,0 +1,8 @@
+# MediaContainerWithPlaylistMetadataGuids
+
+
+## Fields
+
+| Field                                                                                                                                                                                                                            | Type                                                                                                                                                                                                                             | Required                                                                                                                                                                                                                         | Description                                                                                                                                                                                                                      | Example                                                                                                                                                                                                                          |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ID`                                                                                                                                                                                                                             | *string*                                                                                                                                                                                                                         | :heavy_check_mark:                                                                                                                                                                                                               | The unique identifier for the Guid. Can be prefixed with imdb://, tmdb://, tvdb://<br/>                                                                                                                                          | {<br/>"imdbExample": {<br/>"summary": "IMDB example",<br/>"value": "imdb://tt13015952"<br/>},<br/>"tmdbExample": {<br/>"summary": "TMDB example",<br/>"value": "tmdb://2434012"<br/>},<br/>"tvdbExample": {<br/>"summary": "TVDB example",<br/>"value": "tvdb://7945991"<br/>}<br/>} |

docs/models/components/mediacontainerwithplaylistmetadatamediacontainer.md

@@ -0,0 +1,17 @@
+# MediaContainerWithPlaylistMetadataMediaContainer
+
+`MediaContainer` is the root element of most Plex API responses. It serves as a generic container for various types of content (Metadata, Hubs, Directories, etc.) and includes pagination information (offset, size, totalSize) when applicable.
+Common attributes: - identifier: Unique identifier for this container - size: Number of items in this response page - totalSize: Total number of items available (for pagination) - offset: Starting index of this page (for pagination)
+The container often "hoists" common attributes from its children. For example, if all tracks in a container share the same album title, the `parentTitle` attribute may appear on the MediaContainer rather than being repeated on each track.
+
+
+
+## Fields
+
+| Field                                                                                                                                    | Type                                                                                                                                     | Required                                                                                                                                 | Description                                                                                                                              |
+| ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `Identifier`                                                                                                                             | **string*                                                                                                                                | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `Offset`                                                                                                                                 | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The offset of where this container page starts among the total objects available. Also provided in the `X-Plex-Container-Start` header.<br/> |
+| `Size`                                                                                                                                   | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |
+| `TotalSize`                                                                                                                              | **int64*                                                                                                                                 | :heavy_minus_sign:                                                                                                                       | The total size of objects available. Also provided in the `X-Plex-Container-Total-Size` header.<br/>                                     |
+| `Metadata`                                                                                                                               | [][components.MediaContainerWithPlaylistMetadataMetadata](../../models/components/mediacontainerwithplaylistmetadatametadata.md)         | :heavy_minus_sign:                                                                                                                       | N/A                                                                                                                                      |

docs/models/components/mediacontainerwithsettings.md

@@ -0,0 +1,8 @@
+# MediaContainerWithSettings
+
+
+## Fields
+
+| Field                                                                                                                       | Type                                                                                                                        | Required                                                                                                                    | Description                                                                                                                 |
+| --------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| `MediaContainer`                                                                                                            | [*components.MediaContainerWithSettingsMediaContainer](../../models/components/mediacontainerwithsettingsmediacontainer.md) | :heavy_minus_sign:                                                                                                          | N/A                                                                                                                         |