overlay: 1.0.0
info:
  title: CodeSamples overlay for csharp target
  version: 0.0.0
actions:
  - target: $["paths"]["/"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetServerInfoRequest req = new GetServerInfoRequest() {};

            var res = await sdk.General.GetServerInfoAsync(req);

            // handle response
  - target: $["paths"]["/:/eventsource/notifications"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetNotificationsRequest req = new GetNotificationsRequest() {};

            var res = await sdk.Events.GetNotificationsAsync(req);

            // handle response
  - target: $["paths"]["/:/prefs"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Preferences.GetAllPreferencesAsync();

            // handle response
  - target: $["paths"]["/:/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            SetPreferencesRequest req = new SetPreferencesRequest() {
                Prefs = new Prefs() {},
            };

            var res = await sdk.Preferences.SetPreferencesAsync(req);

            // handle response
  - target: $["paths"]["/:/prefs/get"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetPreferenceRequest req = new GetPreferenceRequest() {};

            var res = await sdk.Preferences.GetPreferenceAsync(req);

            // handle response
  - target: $["paths"]["/:/rate"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            SetRatingRequest req = new SetRatingRequest() {
                Identifier = "<value>",
                Key = "<key>",
                Rating = 8722.46D,
            };

            var res = await sdk.Rate.SetRatingAsync(req);

            // handle response
  - target: $["paths"]["/:/scrobble"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            MarkPlayedRequest req = new MarkPlayedRequest() {
                Identifier = "<value>",
            };

            var res = await sdk.Timeline.MarkPlayedAsync(req);

            // handle response
  - target: $["paths"]["/:/timeline"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ReportRequest req = new ReportRequest() {
                Key = "/foo",
                RatingKey = "xyz",
                State = State.Playing,
                PlayQueueItemID = "123",
                Time = 0,
                Duration = 10000,
                Continuing = BoolInt.One,
                Updated = 14200000,
                Offline = BoolInt.One,
                TimeToFirstFrame = 1000,
                TimeStalled = 1000,
                Bandwidth = 100,
                BufferedTime = 100,
                BufferedSize = 1024,
            };

            var res = await sdk.Timeline.ReportAsync(req);

            // handle response
  - target: $["paths"]["/:/unscrobble"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            UnscrobbleRequest req = new UnscrobbleRequest() {
                Identifier = "<value>",
            };

            var res = await sdk.Timeline.UnscrobbleAsync(req);

            // handle response
  - target: $["paths"]["/:/websocket/notifications"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ConnectWebSocketRequest req = new ConnectWebSocketRequest() {};

            var res = await sdk.Events.ConnectWebSocketAsync(req);

            // handle response
  - target: $["paths"]["/activities"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Activities.ListActivitiesAsync();

            // handle response
  - target: $["paths"]["/activities/{activityId}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            CancelActivityRequest req = new CancelActivityRequest() {
                ActivityId = "d6199ba1-fb5e-4cae-bf17-1a5369c1cf1e",
            };

            var res = await sdk.Activities.CancelActivityAsync(req);

            // handle response
  - target: $["paths"]["/butler"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Butler.StopTasksAsync();

            // handle response
  - target: $["paths"]["/butler"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Butler.GetTasksAsync();

            // handle response
  - target: $["paths"]["/butler"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Butler.StartTasksAsync();

            // handle response
  - target: $["paths"]["/butler/{task}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            StopTaskRequest req = new StopTaskRequest() {
                Task = Task.CleanOldBundles,
            };

            var res = await sdk.Butler.StopTaskAsync(req);

            // handle response
  - target: $["paths"]["/butler/{task}"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            StartTaskRequest req = new StartTaskRequest() {
                Task = PathParamTask.RefreshLocalMedia,
            };

            var res = await sdk.Butler.StartTaskAsync(req);

            // handle response
  - target: $["paths"]["/downloadQueue"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.DownloadQueue.CreateDownloadQueueAsync();

            // handle response
  - target: $["paths"]["/downloadQueue/{queueId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetDownloadQueueRequest req = new GetDownloadQueueRequest() {
                QueueId = 922802,
            };

            var res = await sdk.DownloadQueue.GetDownloadQueueAsync(req);

            // handle response
  - target: $["paths"]["/downloadQueue/{queueId}/add"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            AddDownloadQueueItemsRequest req = new AddDownloadQueueItemsRequest() {
                QueueId = 984925,
                Keys = new List<string>() {
                    "/library/metadata/3",
                    "/library/metadata/6",
                },
                AdvancedSubtitles = LukeHagar.PlexAPI.SDK.Models.Components.AdvancedSubtitles.Burn,
                AudioBoost = 50,
                AudioChannelCount = 5,
                AutoAdjustQuality = BoolInt.One,
                AutoAdjustSubtitle = BoolInt.One,
                DirectPlay = BoolInt.One,
                DirectStream = BoolInt.One,
                DirectStreamAudio = BoolInt.One,
                DisableResolutionRotation = BoolInt.One,
                HasMDE = BoolInt.One,
                Location = LukeHagar.PlexAPI.SDK.Models.Components.Location.Wan,
                MediaBufferSize = 102400,
                MediaIndex = 0,
                MusicBitrate = 5000,
                Offset = 90.5D,
                PartIndex = 0,
                Path = "/library/metadata/151671",
                PeakBitrate = 12000,
                PhotoResolution = "1080x1080",
                Protocol = LukeHagar.PlexAPI.SDK.Models.Components.Protocol.Dash,
                SecondsPerSegment = 5,
                SubtitleSize = 50,
                VideoBitrate = 12000,
                VideoQuality = 50,
                VideoResolution = "1080x1080",
            };

            var res = await sdk.DownloadQueue.AddDownloadQueueItemsAsync(req);

            // handle response
  - target: $["paths"]["/downloadQueue/{queueId}/item/{itemId}/decision"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetItemDecisionRequest req = new GetItemDecisionRequest() {
                QueueId = 231605,
                ItemId = 32,
            };

            var res = await sdk.DownloadQueue.GetItemDecisionAsync(req);

            // handle response
  - target: $["paths"]["/downloadQueue/{queueId}/item/{itemId}/media"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetDownloadQueueMediaRequest req = new GetDownloadQueueMediaRequest() {
                QueueId = 663184,
                ItemId = 32,
            };

            var res = await sdk.DownloadQueue.GetDownloadQueueMediaAsync(req);

            // handle response
  - target: $["paths"]["/downloadQueue/{queueId}/items"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ListDownloadQueueItemsRequest req = new ListDownloadQueueItemsRequest() {
                QueueId = 524138,
            };

            var res = await sdk.DownloadQueue.ListDownloadQueueItemsAsync(req);

            // handle response
  - target: $["paths"]["/downloadQueue/{queueId}/items/{itemId}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            RemoveDownloadQueueItemsRequest req = new RemoveDownloadQueueItemsRequest() {
                QueueId = 946275,
                ItemId = new List<long>() {
                    32,
                    345,
                    23,
                },
            };

            var res = await sdk.DownloadQueue.RemoveDownloadQueueItemsAsync(req);

            // handle response
  - target: $["paths"]["/downloadQueue/{queueId}/items/{itemId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetDownloadQueueItemsRequest req = new GetDownloadQueueItemsRequest() {
                QueueId = 809886,
                ItemId = new List<long>() {
                    32,
                    345,
                    23,
                },
            };

            var res = await sdk.DownloadQueue.GetDownloadQueueItemsAsync(req);

            // handle response
  - target: $["paths"]["/downloadQueue/{queueId}/items/{itemId}/restart"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            RestartProcessingDownloadQueueItemsRequest req = new RestartProcessingDownloadQueueItemsRequest() {
                QueueId = 713001,
                ItemId = new List<long>() {
                    32,
                    345,
                    23,
                },
            };

            var res = await sdk.DownloadQueue.RestartProcessingDownloadQueueItemsAsync(req);

            // handle response
  - target: $["paths"]["/hubs"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetAllHubsRequest req = new GetAllHubsRequest() {
                OnlyTransient = BoolInt.One,
            };

            var res = await sdk.Hubs.GetAllHubsAsync(req);

            // handle response
  - target: $["paths"]["/hubs/continueWatching"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetContinueWatchingRequest req = new GetContinueWatchingRequest() {};

            var res = await sdk.Hubs.GetContinueWatchingAsync(req);

            // handle response
  - target: $["paths"]["/hubs/items"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetHubItemsRequest req = new GetHubItemsRequest() {
                Identifier = new List<string>() {
                    "<value 1>",
                    "<value 2>",
                    "<value 3>",
                },
            };

            var res = await sdk.Hubs.GetHubItemsAsync(req);

            // handle response
  - target: $["paths"]["/hubs/metadata/{metadataId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetMetadataHubsRequest req = new GetMetadataHubsRequest() {
                MetadataId = 605482,
                OnlyTransient = BoolInt.One,
            };

            var res = await sdk.Hubs.GetMetadataHubsAsync(req);

            // handle response
  - target: $["paths"]["/hubs/metadata/{metadataId}/postplay"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetPostplayHubsRequest req = new GetPostplayHubsRequest() {
                MetadataId = 441419,
                OnlyTransient = BoolInt.One,
            };

            var res = await sdk.Hubs.GetPostplayHubsAsync(req);

            // handle response
  - target: $["paths"]["/hubs/metadata/{metadataId}/related"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetRelatedHubsRequest req = new GetRelatedHubsRequest() {
                MetadataId = 8858,
                OnlyTransient = BoolInt.One,
            };

            var res = await sdk.Hubs.GetRelatedHubsAsync(req);

            // handle response
  - target: $["paths"]["/hubs/promoted"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetPromotedHubsRequest req = new GetPromotedHubsRequest() {};

            var res = await sdk.Hubs.GetPromotedHubsAsync(req);

            // handle response
  - target: $["paths"]["/hubs/search"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            SearchHubsRequest req = new SearchHubsRequest() {
                Query = "<value>",
                SectionId = 1,
            };

            var res = await sdk.Search.SearchHubsAsync(req);

            // handle response
  - target: $["paths"]["/hubs/search/voice"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            VoiceSearchHubsRequest req = new VoiceSearchHubsRequest() {
                Query = "<value>",
            };

            var res = await sdk.Search.VoiceSearchHubsAsync(req);

            // handle response
  - target: $["paths"]["/hubs/sections/{sectionId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetSectionHubsRequest req = new GetSectionHubsRequest() {
                SectionId = 336924,
                OnlyTransient = BoolInt.One,
            };

            var res = await sdk.Hubs.GetSectionHubsAsync(req);

            // handle response
  - target: $["paths"]["/hubs/sections/{sectionId}/manage"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ResetSectionDefaultsRequest req = new ResetSectionDefaultsRequest() {
                SectionId = 383022,
            };

            var res = await sdk.Hubs.ResetSectionDefaultsAsync(req);

            // handle response
  - target: $["paths"]["/hubs/sections/{sectionId}/manage"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ListHubsRequest req = new ListHubsRequest() {
                SectionId = 442546,
            };

            var res = await sdk.Hubs.ListHubsAsync(req);

            // handle response
  - target: $["paths"]["/hubs/sections/{sectionId}/manage"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            CreateCustomHubRequest req = new CreateCustomHubRequest() {
                SectionId = 869922,
                MetadataItemId = 703843,
                PromotedToRecommended = BoolInt.One,
                PromotedToOwnHome = BoolInt.One,
                PromotedToSharedHome = BoolInt.One,
            };

            var res = await sdk.Hubs.CreateCustomHubAsync(req);

            // handle response
  - target: $["paths"]["/hubs/sections/{sectionId}/manage/move"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            MoveHubRequest req = new MoveHubRequest() {
                SectionId = 755710,
                Identifier = "<value>",
            };

            var res = await sdk.Hubs.MoveHubAsync(req);

            // handle response
  - target: $["paths"]["/hubs/sections/{sectionId}/manage/{identifier}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteCustomHubRequest req = new DeleteCustomHubRequest() {
                SectionId = 625677,
                Identifier = "<value>",
            };

            var res = await sdk.Hubs.DeleteCustomHubAsync(req);

            // handle response
  - target: $["paths"]["/hubs/sections/{sectionId}/manage/{identifier}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            UpdateHubVisibilityRequest req = new UpdateHubVisibilityRequest() {
                SectionId = 341650,
                Identifier = "<value>",
                PromotedToRecommended = BoolInt.One,
                PromotedToOwnHome = BoolInt.One,
                PromotedToSharedHome = BoolInt.One,
            };

            var res = await sdk.Hubs.UpdateHubVisibilityAsync(req);

            // handle response
  - target: $["paths"]["/identity"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;

            var sdk = new PlexAPI();

            var res = await sdk.General.GetIdentityAsync();

            // handle response
  - target: $["paths"]["/library/all"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetLibraryItemsRequest req = new GetLibraryItemsRequest() {};

            var res = await sdk.Library.GetLibraryItemsAsync(req);

            // handle response
  - target: $["paths"]["/library/caches"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Library.DeleteCachesAsync();

            // handle response
  - target: $["paths"]["/library/clean/bundles"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Library.CleanBundlesAsync();

            // handle response
  - target: $["paths"]["/library/collections"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            CreateCollectionRequest req = new CreateCollectionRequest() {
                SectionId = "<id>",
            };

            var res = await sdk.Collections.CreateCollectionAsync(req);

            // handle response
  - target: $["paths"]["/library/collections/{collectionId}/composite/{updatedAt}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetCollectionImageRequest req = new GetCollectionImageRequest() {
                CollectionId = 474227,
                UpdatedAt = 759379,
            };

            var res = await sdk.Content.GetCollectionImageAsync(req);

            // handle response
  - target: $["paths"]["/library/collections/{collectionId}/items"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetCollectionItemsRequest req = new GetCollectionItemsRequest() {
                CollectionId = 314585,
            };

            var res = await sdk.Content.GetCollectionItemsAsync(req);

            // handle response
  - target: $["paths"]["/library/collections/{collectionId}/items"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            AddCollectionItemsRequest req = new AddCollectionItemsRequest() {
                CollectionId = 338144,
                Uri = "https://expensive-bakeware.com",
            };

            var res = await sdk.LibraryCollections.AddCollectionItemsAsync(req);

            // handle response
  - target: $["paths"]["/library/collections/{collectionId}/items/{itemId}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteCollectionItemRequest req = new DeleteCollectionItemRequest() {
                CollectionId = 320928,
                ItemId = 406983,
            };

            var res = await sdk.LibraryCollections.DeleteCollectionItemAsync(req);

            // handle response
  - target: $["paths"]["/library/collections/{collectionId}/items/{itemId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            MoveCollectionItemRequest req = new MoveCollectionItemRequest() {
                CollectionId = 239532,
                ItemId = 513864,
            };

            var res = await sdk.LibraryCollections.MoveCollectionItemAsync(req);

            // handle response
  - target: $["paths"]["/library/file"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            IngestTransientItemRequest req = new IngestTransientItemRequest() {
                Url = "file:///storage%2Femulated%2F0%2FArcher-S01E01.mkv",
                VirtualFilePath = "/Avatar.mkv",
                ComputeHashes = BoolInt.One,
                IngestNonMatches = BoolInt.One,
            };

            var res = await sdk.Library.IngestTransientItemAsync(req);

            // handle response
  - target: $["paths"]["/library/matches"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetLibraryMatchesRequest req = new GetLibraryMatchesRequest() {
                IncludeFullMetadata = BoolInt.One,
                IncludeAncestorMetadata = BoolInt.One,
                IncludeAlternateMetadataSources = BoolInt.One,
            };

            var res = await sdk.Library.GetLibraryMatchesAsync(req);

            // handle response
  - target: $["paths"]["/library/media/{mediaId}/chapterImages/{chapter}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetChapterImageRequest req = new GetChapterImageRequest() {
                MediaId = 892563,
                Chapter = 48348,
            };

            var res = await sdk.Library.GetChapterImageAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/augmentations/{augmentationId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetAugmentationStatusRequest req = new GetAugmentationStatusRequest() {
                AugmentationId = "<id>",
                Wait = BoolInt.One,
            };

            var res = await sdk.Library.GetAugmentationStatusAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteMetadataItemRequest req = new DeleteMetadataItemRequest() {
                Ids = "<value>",
                Proxy = BoolInt.One,
            };

            var res = await sdk.Library.DeleteMetadataItemAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetMetadataItemRequest req = new GetMetadataItemRequest() {
                Ids = new List<string>() {},
                AsyncCheckFiles = BoolInt.One,
                AsyncRefreshLocalMediaAgent = BoolInt.One,
                AsyncRefreshAnalysis = BoolInt.One,
                CheckFiles = BoolInt.One,
                SkipRefresh = BoolInt.One,
                CheckFileAvailability = BoolInt.One,
                AsyncAugmentMetadata = BoolInt.One,
                AugmentCount = BoolInt.One,
            };

            var res = await sdk.Content.GetMetadataItemAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            EditMetadataItemRequest req = new EditMetadataItemRequest() {
                Ids = new List<string>() {
                    "<value 1>",
                    "<value 2>",
                },
            };

            var res = await sdk.Library.EditMetadataItemAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/addetect"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DetectAdsRequest req = new DetectAdsRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.DetectAdsAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/allLeaves"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetAllItemLeavesRequest req = new GetAllItemLeavesRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.GetAllItemLeavesAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/analyze"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            AnalyzeMetadataRequest req = new AnalyzeMetadataRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.AnalyzeMetadataAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/chapterThumbs"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GenerateThumbsRequest req = new GenerateThumbsRequest() {
                Ids = "<value>",
                Force = BoolInt.One,
            };

            var res = await sdk.Library.GenerateThumbsAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/credits"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DetectCreditsRequest req = new DetectCreditsRequest() {
                Ids = "<value>",
                Force = BoolInt.One,
                Manual = BoolInt.One,
            };

            var res = await sdk.Library.DetectCreditsAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/extras"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetExtrasRequest req = new GetExtrasRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.GetExtrasAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/extras"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            AddExtrasRequest req = new AddExtrasRequest() {
                Ids = "<value>",
                Url = "https://super-mortise.biz/",
            };

            var res = await sdk.Library.AddExtrasAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/file"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetFileRequest req = new GetFileRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.GetFileAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/index"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            StartBifGenerationRequest req = new StartBifGenerationRequest() {
                Ids = "<value>",
                Force = BoolInt.One,
            };

            var res = await sdk.Library.StartBifGenerationAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/intro"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DetectIntrosRequest req = new DetectIntrosRequest() {
                Ids = "<value>",
                Force = BoolInt.One,
            };

            var res = await sdk.Library.DetectIntrosAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/marker"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            CreateMarkerRequest req = new CreateMarkerRequest() {
                Ids = "<value>",
                Type = 248391,
                StartTimeOffset = 535191,
                Attributes = new Attributes() {},
            };

            var res = await sdk.Library.CreateMarkerAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/marker/{marker}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteMarkerRequest req = new DeleteMarkerRequest() {
                Ids = "<value>",
                Marker = "<value>",
            };

            var res = await sdk.Library.DeleteMarkerAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/marker/{marker}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            EditMarkerRequest req = new EditMarkerRequest() {
                Ids = "<value>",
                Marker = "<value>",
                Type = 884347,
                StartTimeOffset = 517251,
                Attributes = new QueryParamAttributes() {},
            };

            var res = await sdk.Library.EditMarkerAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/match"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            MatchItemRequest req = new MatchItemRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.MatchItemAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/matches"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ListMatchesRequest req = new ListMatchesRequest() {
                Ids = "<value>",
                Manual = BoolInt.One,
            };

            var res = await sdk.Library.ListMatchesAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/media/{mediaItem}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteMediaItemRequest req = new DeleteMediaItemRequest() {
                Ids = "<value>",
                MediaItem = "<value>",
                Proxy = BoolInt.One,
            };

            var res = await sdk.Library.DeleteMediaItemAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/merge"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            MergeItemsRequest req = new MergeItemsRequest() {
                IdsPathParameter = "<value>",
            };

            var res = await sdk.Library.MergeItemsAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/nearest"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ListSonicallySimilarRequest req = new ListSonicallySimilarRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.ListSonicallySimilarAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            SetItemPreferencesRequest req = new SetItemPreferencesRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.SetItemPreferencesAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/refresh"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            RefreshItemsMetadataRequest req = new RefreshItemsMetadataRequest() {
                Ids = "<value>",
                MarkUpdated = BoolInt.One,
            };

            var res = await sdk.Library.RefreshItemsMetadataAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/related"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetRelatedItemsRequest req = new GetRelatedItemsRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.GetRelatedItemsAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/similar"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ListSimilarRequest req = new ListSimilarRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.ListSimilarAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/split"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            SplitItemRequest req = new SplitItemRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.SplitItemAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/subtitles"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            AddSubtitlesRequest req = new AddSubtitlesRequest() {
                Ids = "<value>",
                Forced = BoolInt.One,
                HearingImpaired = BoolInt.One,
            };

            var res = await sdk.Library.AddSubtitlesAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/tree"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetItemTreeRequest req = new GetItemTreeRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.GetItemTreeAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/unmatch"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            UnmatchRequest req = new UnmatchRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.UnmatchAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/users/top"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ListTopUsersRequest req = new ListTopUsersRequest() {
                Ids = "<value>",
            };

            var res = await sdk.Library.ListTopUsersAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/voiceActivity"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DetectVoiceActivityRequest req = new DetectVoiceActivityRequest() {
                Ids = "<value>",
                Force = BoolInt.One,
                Manual = BoolInt.One,
            };

            var res = await sdk.Library.DetectVoiceActivityAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/{element}"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            SetItemArtworkRequest req = new SetItemArtworkRequest() {
                Ids = "<value>",
                Element = Element.Banner,
            };

            var res = await sdk.Library.SetItemArtworkAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/{element}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            UpdateItemArtworkRequest req = new UpdateItemArtworkRequest() {
                Ids = "<value>",
                Element = PathParamElement.ClearLogo,
            };

            var res = await sdk.Library.UpdateItemArtworkAsync(req);

            // handle response
  - target: $["paths"]["/library/metadata/{ids}/{element}/{timestamp}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetItemArtworkRequest req = new GetItemArtworkRequest() {
                Ids = "<value>",
                Element = GetItemArtworkPathParamElement.Poster,
                Timestamp = 999555,
            };

            var res = await sdk.Library.GetItemArtworkAsync(req);

            // handle response
  - target: $["paths"]["/library/optimize"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            OptimizeDatabaseRequest req = new OptimizeDatabaseRequest() {
                Async = BoolInt.One,
            };

            var res = await sdk.Library.OptimizeDatabaseAsync(req);

            // handle response
  - target: $["paths"]["/library/parts/{partId}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            SetStreamSelectionRequest req = new SetStreamSelectionRequest() {
                PartId = 360489,
                AllParts = BoolInt.One,
            };

            var res = await sdk.Library.SetStreamSelectionAsync(req);

            // handle response
  - target: $["paths"]["/library/parts/{partId}/indexes/{index}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetPartIndexRequest req = new GetPartIndexRequest() {
                PartId = 724750,
                Index = Index.Sd,
            };

            var res = await sdk.Library.GetPartIndexAsync(req);

            // handle response
  - target: $["paths"]["/library/parts/{partId}/indexes/{index}/{offset}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetImageFromBifRequest req = new GetImageFromBifRequest() {
                PartId = 304273,
                Index = PathParamIndex.Sd,
                Offset = 939569,
            };

            var res = await sdk.Library.GetImageFromBifAsync(req);

            // handle response
  - target: $["paths"]["/library/parts/{partId}/{changestamp}/{filename}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetMediaPartRequest req = new GetMediaPartRequest() {
                PartId = 877105,
                Changestamp = 970622,
                Filename = "example.file",
                Download = BoolInt.One,
            };

            var res = await sdk.Library.GetMediaPartAsync(req);

            // handle response
  - target: $["paths"]["/library/people/{personId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetPersonRequest req = new GetPersonRequest() {
                PersonId = "<id>",
            };

            var res = await sdk.Library.GetPersonAsync(req);

            // handle response
  - target: $["paths"]["/library/people/{personId}/media"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ListPersonMediaRequest req = new ListPersonMediaRequest() {
                PersonId = "<id>",
            };

            var res = await sdk.Library.ListPersonMediaAsync(req);

            // handle response
  - target: $["paths"]["/library/randomArtwork"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetRandomArtworkRequest req = new GetRandomArtworkRequest() {
                Sections = new List<long>() {
                    5,
                    6,
                },
            };

            var res = await sdk.Library.GetRandomArtworkAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/all"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Library.GetSectionsAsync();

            // handle response
  - target: $["paths"]["/library/sections/all"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            AddSectionRequest req = new AddSectionRequest() {
                Name = "<value>",
                Type = 39544,
                Agent = "<value>",
                Language = "<value>",
                Locations = new List<string>() {
                    "O:\fatboy\Media\Ripped\Music",
                    "O:\fatboy\Media\My Music",
                },
                Prefs = new QueryParamPrefs() {},
                Relative = BoolInt.One,
                ImportFromiTunes = BoolInt.One,
            };

            var res = await sdk.Library.AddSectionAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/all/refresh"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Library.StopAllRefreshesAsync();

            // handle response
  - target: $["paths"]["/library/sections/prefs"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetSectionsPrefsRequest req = new GetSectionsPrefsRequest() {
                Type = 460221,
            };

            var res = await sdk.Library.GetSectionsPrefsAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/refresh"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            RefreshSectionsMetadataRequest req = new RefreshSectionsMetadataRequest() {};

            var res = await sdk.Library.RefreshSectionsMetadataAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteLibrarySectionRequest req = new DeleteLibrarySectionRequest() {
                SectionId = "<id>",
                Async = BoolInt.One,
            };

            var res = await sdk.Library.DeleteLibrarySectionAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetLibraryDetailsRequest req = new GetLibraryDetailsRequest() {
                SectionId = "<id>",
                IncludeDetails = BoolInt.One,
            };

            var res = await sdk.Library.GetLibraryDetailsAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            EditSectionRequest req = new EditSectionRequest() {
                SectionId = "<id>",
                Agent = "<value>",
                Locations = new List<string>() {
                    "O:\fatboy\Media\Ripped\Music",
                    "O:\fatboy\Media\My Music",
                },
                Prefs = new EditSectionQueryParamPrefs() {},
            };

            var res = await sdk.Library.EditSectionAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/albums"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetAlbumsRequest req = new GetAlbumsRequest() {
                SectionId = 817133,
            };

            var res = await sdk.Content.GetAlbumsAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/all"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ListContentRequest req = new ListContentRequest() {
                SectionId = "<id>",
            };

            var res = await sdk.Content.ListContentAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/all"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            UpdateItemsRequest req = new UpdateItemsRequest() {
                SectionId = "<id>",
                FieldLocked = BoolInt.One,
            };

            var res = await sdk.Library.UpdateItemsAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/allLeaves"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetAllLeavesRequest req = new GetAllLeavesRequest() {
                SectionId = 633197,
            };

            var res = await sdk.Content.GetAllLeavesAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/analyze"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            StartAnalysisRequest req = new StartAnalysisRequest() {
                SectionId = 158829,
            };

            var res = await sdk.Library.StartAnalysisAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/arts"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetArtsRequest req = new GetArtsRequest() {
                SectionId = 859200,
            };

            var res = await sdk.Content.GetArtsAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/autocomplete"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            AutocompleteRequest req = new AutocompleteRequest() {
                SectionId = 942007,
            };

            var res = await sdk.Library.AutocompleteAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/categories"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetCategoriesRequest req = new GetCategoriesRequest() {
                SectionId = 21841,
            };

            var res = await sdk.Content.GetCategoriesAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/cluster"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetClusterRequest req = new GetClusterRequest() {
                SectionId = 138560,
            };

            var res = await sdk.Content.GetClusterAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/collection/{collectionId}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteCollectionRequest req = new DeleteCollectionRequest() {
                SectionId = 283619,
                CollectionId = 680895,
            };

            var res = await sdk.Library.DeleteCollectionAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/collections"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetCollectionsRequest req = new GetCollectionsRequest() {
                SectionId = 348838,
            };

            var res = await sdk.Library.GetCollectionsAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/common"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetCommonRequest req = new GetCommonRequest() {
                SectionId = 298154,
            };

            var res = await sdk.Library.GetCommonAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/composite/{updatedAt}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetSectionImageRequest req = new GetSectionImageRequest() {
                SectionId = 925611,
                UpdatedAt = 117413,
            };

            var res = await sdk.Library.GetSectionImageAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/computePath"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetSonicPathRequest req = new GetSonicPathRequest() {
                SectionId = 914549,
                StartID = 629990,
                EndID = 687740,
            };

            var res = await sdk.Content.GetSonicPathAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/emptyTrash"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            EmptyTrashRequest req = new EmptyTrashRequest() {
                SectionId = 30052,
            };

            var res = await sdk.Library.EmptyTrashAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/filters"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetSectionFiltersRequest req = new GetSectionFiltersRequest() {
                SectionId = 380557,
            };

            var res = await sdk.Library.GetSectionFiltersAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/firstCharacters"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetFirstCharactersRequest req = new GetFirstCharactersRequest() {
                SectionId = 3947,
            };

            var res = await sdk.Library.GetFirstCharactersAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/indexes"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteIndexesRequest req = new DeleteIndexesRequest() {
                SectionId = 588437,
            };

            var res = await sdk.Library.DeleteIndexesAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/intros"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteIntrosRequest req = new DeleteIntrosRequest() {
                SectionId = 498656,
            };

            var res = await sdk.Library.DeleteIntrosAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/location"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetFoldersRequest req = new GetFoldersRequest() {
                SectionId = 892532,
            };

            var res = await sdk.Content.GetFoldersAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/moment"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ListMomentsRequest req = new ListMomentsRequest() {
                SectionId = 403239,
            };

            var res = await sdk.Content.ListMomentsAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/nearest"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetSonicallySimilarRequest req = new GetSonicallySimilarRequest() {
                SectionId = 525956,
                Values = new List<long>() {},
            };

            var res = await sdk.Content.GetSonicallySimilarAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/prefs"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetSectionPreferencesRequest req = new GetSectionPreferencesRequest() {
                SectionId = 754869,
            };

            var res = await sdk.Library.GetSectionPreferencesAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            SetSectionPreferencesRequest req = new SetSectionPreferencesRequest() {
                SectionId = 349936,
                Prefs = new SetSectionPreferencesQueryParamPrefs() {},
            };

            var res = await sdk.Library.SetSectionPreferencesAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/refresh"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            CancelRefreshRequest req = new CancelRefreshRequest() {
                SectionId = 326852,
            };

            var res = await sdk.Library.CancelRefreshAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/refresh"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            RefreshSectionRequest req = new RefreshSectionRequest() {
                SectionId = 450300,
                Force = BoolInt.One,
            };

            var res = await sdk.Library.RefreshSectionAsync(req);

            // handle response
  - target: $["paths"]["/library/sections/{sectionId}/sorts"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetAvailableSortsRequest req = new GetAvailableSortsRequest() {
                SectionId = 212498,
            };

            var res = await sdk.Library.GetAvailableSortsAsync(req);

            // handle response
  - target: $["paths"]["/library/streams/{streamId}.{ext}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteStreamRequest req = new DeleteStreamRequest() {
                StreamId = 841510,
                Ext = "<value>",
            };

            var res = await sdk.Library.DeleteStreamAsync(req);

            // handle response
  - target: $["paths"]["/library/streams/{streamId}.{ext}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetStreamRequest req = new GetStreamRequest() {
                StreamId = 314506,
                Ext = "<value>",
                AutoAdjustSubtitle = BoolInt.One,
            };

            var res = await sdk.Library.GetStreamAsync(req);

            // handle response
  - target: $["paths"]["/library/streams/{streamId}.{ext}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            SetStreamOffsetRequest req = new SetStreamOffsetRequest() {
                StreamId = 606295,
                Ext = "<value>",
            };

            var res = await sdk.Library.SetStreamOffsetAsync(req);

            // handle response
  - target: $["paths"]["/library/streams/{streamId}/levels"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetStreamLevelsRequest req = new GetStreamLevelsRequest() {
                StreamId = 447611,
            };

            var res = await sdk.Library.GetStreamLevelsAsync(req);

            // handle response
  - target: $["paths"]["/library/streams/{streamId}/loudness"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetStreamLoudnessRequest req = new GetStreamLoudnessRequest() {
                StreamId = 277271,
            };

            var res = await sdk.Library.GetStreamLoudnessAsync(req);

            // handle response
  - target: $["paths"]["/library/tags"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetTagsRequest req = new GetTagsRequest() {};

            var res = await sdk.Library.GetTagsAsync(req);

            // handle response
  - target: $["paths"]["/livetv/dvrs"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.DVRs.ListDVRsAsync();

            // handle response
  - target: $["paths"]["/livetv/dvrs"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            CreateDVRRequest req = new CreateDVRRequest() {
                Lineup = "lineup://tv.plex.providers.epg.onconnect/USA-HI51418-DEFAULT",
                DeviceQueryParameter = new List<string>() {
                    "d",
                    "e",
                    "v",
                    "i",
                    "c",
                    "e",
                    "[",
                    "]",
                    "=",
                    "d",
                    "e",
                    "v",
                    "i",
                    "c",
                    "e",
                    ":",
                    "/",
                    "/",
                    "t",
                    "v",
                    ".",
                    "p",
                    "l",
                    "e",
                    "x",
                    ".",
                    "g",
                    "r",
                    "a",
                    "b",
                    "b",
                    "e",
                    "r",
                    "s",
                    ".",
                    "h",
                    "d",
                    "h",
                    "o",
                    "m",
                    "e",
                    "r",
                    "u",
                    "n",
                    "/",
                    "1",
                    "0",
                    "5",
                    "3",
                    "C",
                    "0",
                    "C",
                    "A",
                },
                Language = "eng",
            };

            var res = await sdk.DVRs.CreateDVRAsync(req);

            // handle response
  - target: $["paths"]["/livetv/dvrs/{dvrId}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteDVRRequest req = new DeleteDVRRequest() {
                DvrId = 855088,
            };

            var res = await sdk.DVRs.DeleteDVRAsync(req);

            // handle response
  - target: $["paths"]["/livetv/dvrs/{dvrId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetDVRRequest req = new GetDVRRequest() {
                DvrId = 973518,
            };

            var res = await sdk.DVRs.GetDVRAsync(req);

            // handle response
  - target: $["paths"]["/livetv/dvrs/{dvrId}/channels/{channel}/tune"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            TuneChannelRequest req = new TuneChannelRequest() {
                DvrId = 834281,
                Channel = "2.1",
            };

            var res = await sdk.DVRs.TuneChannelAsync(req);

            // handle response
  - target: $["paths"]["/livetv/dvrs/{dvrId}/devices/{deviceId}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            RemoveDeviceFromDVRRequest req = new RemoveDeviceFromDVRRequest() {
                DvrId = 945416,
                DeviceId = 260761,
            };

            var res = await sdk.DVRs.RemoveDeviceFromDVRAsync(req);

            // handle response
  - target: $["paths"]["/livetv/dvrs/{dvrId}/devices/{deviceId}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            AddDeviceToDVRRequest req = new AddDeviceToDVRRequest() {
                DvrId = 334755,
                DeviceId = 852930,
            };

            var res = await sdk.DVRs.AddDeviceToDVRAsync(req);

            // handle response
  - target: $["paths"]["/livetv/dvrs/{dvrId}/lineups"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteLineupRequest req = new DeleteLineupRequest() {
                DvrId = 454470,
                Lineup = "<value>",
            };

            var res = await sdk.DVRs.DeleteLineupAsync(req);

            // handle response
  - target: $["paths"]["/livetv/dvrs/{dvrId}/lineups"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            AddLineupRequest req = new AddLineupRequest() {
                DvrId = 945235,
                Lineup = "<value>",
            };

            var res = await sdk.DVRs.AddLineupAsync(req);

            // handle response
  - target: $["paths"]["/livetv/dvrs/{dvrId}/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            SetDVRPreferencesRequest req = new SetDVRPreferencesRequest() {
                DvrId = 116357,
            };

            var res = await sdk.DVRs.SetDVRPreferencesAsync(req);

            // handle response
  - target: $["paths"]["/livetv/dvrs/{dvrId}/reloadGuide"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            StopDVRReloadRequest req = new StopDVRReloadRequest() {
                DvrId = 348053,
            };

            var res = await sdk.DVRs.StopDVRReloadAsync(req);

            // handle response
  - target: $["paths"]["/livetv/dvrs/{dvrId}/reloadGuide"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ReloadGuideRequest req = new ReloadGuideRequest() {
                DvrId = 140753,
            };

            var res = await sdk.DVRs.ReloadGuideAsync(req);

            // handle response
  - target: $["paths"]["/livetv/epg/channelmap"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ComputeChannelMapRequest req = new ComputeChannelMapRequest() {
                DeviceQueryParameter = "<value>",
                Lineup = "<value>",
            };

            var res = await sdk.Epg.ComputeChannelMapAsync(req);

            // handle response
  - target: $["paths"]["/livetv/epg/channels"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetChannelsRequest req = new GetChannelsRequest() {
                Lineup = "<value>",
            };

            var res = await sdk.Epg.GetChannelsAsync(req);

            // handle response
  - target: $["paths"]["/livetv/epg/countries"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Epg.GetCountriesAsync();

            // handle response
  - target: $["paths"]["/livetv/epg/countries/{country}/{epgId}/lineups"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetCountriesLineupsRequest req = new GetCountriesLineupsRequest() {
                Country = "Malawi",
                EpgId = "<id>",
            };

            var res = await sdk.Epg.GetCountriesLineupsAsync(req);

            // handle response
  - target: $["paths"]["/livetv/epg/countries/{country}/{epgId}/regions"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetCountryRegionsRequest req = new GetCountryRegionsRequest() {
                Country = "Morocco",
                EpgId = "<id>",
            };

            var res = await sdk.Epg.GetCountryRegionsAsync(req);

            // handle response
  - target: $["paths"]["/livetv/epg/countries/{country}/{epgId}/regions/{region}/lineups"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ListLineupsRequest req = new ListLineupsRequest() {
                Country = "Vanuatu",
                EpgId = "<id>",
                Region = "<value>",
            };

            var res = await sdk.Epg.ListLineupsAsync(req);

            // handle response
  - target: $["paths"]["/livetv/epg/languages"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Epg.GetAllLanguagesAsync();

            // handle response
  - target: $["paths"]["/livetv/epg/lineup"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetLineupRequest req = new GetLineupRequest() {
                DeviceQueryParameter = "<value>",
                LineupGroup = "<value>",
            };

            var res = await sdk.Epg.GetLineupAsync(req);

            // handle response
  - target: $["paths"]["/livetv/epg/lineupchannels"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetLineupChannelsRequest req = new GetLineupChannelsRequest() {
                Lineup = new List<string>() {
                    "<value 1>",
                    "<value 2>",
                },
            };

            var res = await sdk.Epg.GetLineupChannelsAsync(req);

            // handle response
  - target: $["paths"]["/livetv/sessions"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.LiveTV.GetSessionsAsync();

            // handle response
  - target: $["paths"]["/livetv/sessions/{sessionId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetLiveTVSessionRequest req = new GetLiveTVSessionRequest() {
                SessionId = "<id>",
            };

            var res = await sdk.LiveTV.GetLiveTVSessionAsync(req);

            // handle response
  - target: $["paths"]["/livetv/sessions/{sessionId}/{consumerId}/index.m3u8"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetSessionPlaylistIndexRequest req = new GetSessionPlaylistIndexRequest() {
                SessionId = "<id>",
                ConsumerId = "<id>",
            };

            var res = await sdk.LiveTV.GetSessionPlaylistIndexAsync(req);

            // handle response
  - target: $["paths"]["/livetv/sessions/{sessionId}/{consumerId}/{segmentId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetSessionSegmentRequest req = new GetSessionSegmentRequest() {
                SessionId = "<id>",
                ConsumerId = "<id>",
                SegmentId = "<id>",
            };

            var res = await sdk.LiveTV.GetSessionSegmentAsync(req);

            // handle response
  - target: $["paths"]["/log"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using System;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            byte[] req = System.Text.Encoding.UTF8.GetBytes("0x0Ce2fFcEBF");

            var res = await sdk.Log.WriteLogAsync(req);

            // handle response
  - target: $["paths"]["/log"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            WriteMessageRequest req = new WriteMessageRequest() {};

            var res = await sdk.Log.WriteMessageAsync(req);

            // handle response
  - target: $["paths"]["/log/networked"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            EnablePapertrailRequest req = new EnablePapertrailRequest() {};

            var res = await sdk.Log.EnablePapertrailAsync(req);

            // handle response
  - target: $["paths"]["/media/grabbers"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetAvailableGrabbersRequest req = new GetAvailableGrabbersRequest() {
                Protocol = "livetv",
            };

            var res = await sdk.Devices.GetAvailableGrabbersAsync(req);

            // handle response
  - target: $["paths"]["/media/grabbers/devices"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Devices.ListDevicesAsync();

            // handle response
  - target: $["paths"]["/media/grabbers/devices"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            AddDeviceRequest req = new AddDeviceRequest() {
                Uri = "http://10.0.0.5",
            };

            var res = await sdk.Devices.AddDeviceAsync(req);

            // handle response
  - target: $["paths"]["/media/grabbers/devices/discover"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Devices.DiscoverDevicesAsync();

            // handle response
  - target: $["paths"]["/media/grabbers/devices/{deviceId}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            RemoveDeviceRequest req = new RemoveDeviceRequest() {
                DeviceId = 685908,
            };

            var res = await sdk.Devices.RemoveDeviceAsync(req);

            // handle response
  - target: $["paths"]["/media/grabbers/devices/{deviceId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetDeviceDetailsRequest req = new GetDeviceDetailsRequest() {
                DeviceId = 170949,
            };

            var res = await sdk.Devices.GetDeviceDetailsAsync(req);

            // handle response
  - target: $["paths"]["/media/grabbers/devices/{deviceId}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ModifyDeviceRequest req = new ModifyDeviceRequest() {
                DeviceId = 879135,
                Enabled = BoolInt.One,
            };

            var res = await sdk.Devices.ModifyDeviceAsync(req);

            // handle response
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/channelmap"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            SetChannelmapRequest req = new SetChannelmapRequest() {
                DeviceId = 937661,
                ChannelMapping = new LukeHagar.PlexAPI.SDK.Models.Requests.ChannelMapping() {},
                ChannelMappingByKey = new ChannelMappingByKey() {},
                ChannelsEnabled = new List<string>() {
                    "4",
                    "6",
                    ".",
                    "1",
                    ",",
                    "4",
                    "4",
                    ".",
                    "1",
                    ",",
                    "4",
                    "5",
                    ".",
                    "1",
                },
            };

            var res = await sdk.Devices.SetChannelmapAsync(req);

            // handle response
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/channels"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetDevicesChannelsRequest req = new GetDevicesChannelsRequest() {
                DeviceId = 517209,
            };

            var res = await sdk.Devices.GetDevicesChannelsAsync(req);

            // handle response
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            SetDevicePreferencesRequest req = new SetDevicePreferencesRequest() {
                DeviceId = 420973,
            };

            var res = await sdk.Devices.SetDevicePreferencesAsync(req);

            // handle response
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/scan"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            StopScanRequest req = new StopScanRequest() {
                DeviceId = 576494,
            };

            var res = await sdk.Devices.StopScanAsync(req);

            // handle response
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/scan"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ScanRequest req = new ScanRequest() {
                DeviceId = 57391,
                Source = "Cable",
            };

            var res = await sdk.Devices.ScanAsync(req);

            // handle response
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/thumb/{version}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetThumbRequest req = new GetThumbRequest() {
                DeviceId = 960617,
                VersionPathParameter = 1025,
            };

            var res = await sdk.Devices.GetThumbAsync(req);

            // handle response
  - target: $["paths"]["/media/grabbers/operations/{operationId}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            CancelGrabRequest req = new CancelGrabRequest() {
                OperationId = "<id>",
            };

            var res = await sdk.Subscriptions.CancelGrabAsync(req);

            // handle response
  - target: $["paths"]["/media/providers"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Provider.ListProvidersAsync();

            // handle response
  - target: $["paths"]["/media/providers"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            AddProviderRequest req = new AddProviderRequest() {
                Url = "https://steep-obedience.name/",
            };

            var res = await sdk.Provider.AddProviderAsync(req);

            // handle response
  - target: $["paths"]["/media/providers/refresh"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Provider.RefreshProvidersAsync();

            // handle response
  - target: $["paths"]["/media/providers/{provider}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteMediaProviderRequest req = new DeleteMediaProviderRequest() {
                Provider = "<value>",
            };

            var res = await sdk.Provider.DeleteMediaProviderAsync(req);

            // handle response
  - target: $["paths"]["/media/subscriptions"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetAllSubscriptionsRequest req = new GetAllSubscriptionsRequest() {
                IncludeGrabs = BoolInt.One,
                IncludeStorage = BoolInt.One,
            };

            var res = await sdk.Subscriptions.GetAllSubscriptionsAsync(req);

            // handle response
  - target: $["paths"]["/media/subscriptions"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            CreateSubscriptionRequest req = new CreateSubscriptionRequest() {
                TargetLibrarySectionID = 1,
                TargetSectionLocationID = 3,
                Type = 2,
                Hints = new Hints() {},
                Prefs = new CreateSubscriptionQueryParamPrefs() {},
                Params = new Params() {},
            };

            var res = await sdk.Subscriptions.CreateSubscriptionAsync(req);

            // handle response
  - target: $["paths"]["/media/subscriptions/process"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Subscriptions.ProcessSubscriptionsAsync();

            // handle response
  - target: $["paths"]["/media/subscriptions/scheduled"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Subscriptions.GetScheduledRecordingsAsync();

            // handle response
  - target: $["paths"]["/media/subscriptions/template"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetTemplateRequest req = new GetTemplateRequest() {
                Guid = "plex://episode/5fc70265c40548002d539d23",
            };

            var res = await sdk.Subscriptions.GetTemplateAsync(req);

            // handle response
  - target: $["paths"]["/media/subscriptions/{subscriptionId}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteSubscriptionRequest req = new DeleteSubscriptionRequest() {
                SubscriptionId = 974618,
            };

            var res = await sdk.Subscriptions.DeleteSubscriptionAsync(req);

            // handle response
  - target: $["paths"]["/media/subscriptions/{subscriptionId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetSubscriptionRequest req = new GetSubscriptionRequest() {
                SubscriptionId = 186713,
                IncludeGrabs = BoolInt.One,
                IncludeStorage = BoolInt.One,
            };

            var res = await sdk.Subscriptions.GetSubscriptionAsync(req);

            // handle response
  - target: $["paths"]["/media/subscriptions/{subscriptionId}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            EditSubscriptionPreferencesRequest req = new EditSubscriptionPreferencesRequest() {
                SubscriptionId = 673918,
                Prefs = new EditSubscriptionPreferencesQueryParamPrefs() {},
            };

            var res = await sdk.Subscriptions.EditSubscriptionPreferencesAsync(req);

            // handle response
  - target: $["paths"]["/media/subscriptions/{subscriptionId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ReorderSubscriptionRequest req = new ReorderSubscriptionRequest() {
                SubscriptionId = 440634,
            };

            var res = await sdk.Subscriptions.ReorderSubscriptionAsync(req);

            // handle response
  - target: $["paths"]["/photo/:/transcode"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            TranscodeImageRequest req = new TranscodeImageRequest() {
                Url = "/library/metadata/265/thumb/1715112705",
                Background = "#ff5522",
                Upscale = BoolInt.One,
                MinSize = BoolInt.One,
                Rotate = BoolInt.One,
                BlendColor = "#ff5522",
            };

            var res = await sdk.Transcoder.TranscodeImageAsync(req);

            // handle response
  - target: $["paths"]["/playQueues"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            CreatePlayQueueRequest req = new CreatePlayQueueRequest() {
                Type = LukeHagar.PlexAPI.SDK.Models.Requests.Type.Audio,
                Shuffle = BoolInt.One,
                Repeat = BoolInt.One,
                Continuous = BoolInt.One,
                Recursive = BoolInt.One,
                OnDeck = BoolInt.One,
            };

            var res = await sdk.PlayQueue.CreatePlayQueueAsync(req);

            // handle response
  - target: $["paths"]["/playQueues/{playQueueId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetPlayQueueRequest req = new GetPlayQueueRequest() {
                PlayQueueId = 210646,
                Own = BoolInt.One,
                IncludeBefore = BoolInt.One,
                IncludeAfter = BoolInt.One,
            };

            var res = await sdk.PlayQueue.GetPlayQueueAsync(req);

            // handle response
  - target: $["paths"]["/playQueues/{playQueueId}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            AddToPlayQueueRequest req = new AddToPlayQueueRequest() {
                PlayQueueId = 919248,
                Next = BoolInt.One,
            };

            var res = await sdk.PlayQueue.AddToPlayQueueAsync(req);

            // handle response
  - target: $["paths"]["/playQueues/{playQueueId}/items"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ClearPlayQueueRequest req = new ClearPlayQueueRequest() {
                PlayQueueId = 86357,
            };

            var res = await sdk.PlayQueue.ClearPlayQueueAsync(req);

            // handle response
  - target: $["paths"]["/playQueues/{playQueueId}/items/{playQueueItemId}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeletePlayQueueItemRequest req = new DeletePlayQueueItemRequest() {
                PlayQueueId = 285738,
                PlayQueueItemId = 464354,
            };

            var res = await sdk.PlayQueue.DeletePlayQueueItemAsync(req);

            // handle response
  - target: $["paths"]["/playQueues/{playQueueId}/items/{playQueueItemId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            MovePlayQueueItemRequest req = new MovePlayQueueItemRequest() {
                PlayQueueId = 31341,
                PlayQueueItemId = 495865,
            };

            var res = await sdk.PlayQueue.MovePlayQueueItemAsync(req);

            // handle response
  - target: $["paths"]["/playQueues/{playQueueId}/reset"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ResetPlayQueueRequest req = new ResetPlayQueueRequest() {
                PlayQueueId = 581891,
            };

            var res = await sdk.PlayQueue.ResetPlayQueueAsync(req);

            // handle response
  - target: $["paths"]["/playQueues/{playQueueId}/shuffle"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ShuffleRequest req = new ShuffleRequest() {
                PlayQueueId = 316150,
            };

            var res = await sdk.PlayQueue.ShuffleAsync(req);

            // handle response
  - target: $["paths"]["/playQueues/{playQueueId}/unshuffle"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            UnshuffleRequest req = new UnshuffleRequest() {
                PlayQueueId = 484388,
            };

            var res = await sdk.PlayQueue.UnshuffleAsync(req);

            // handle response
  - target: $["paths"]["/playlists"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ListPlaylistsRequest req = new ListPlaylistsRequest() {};

            var res = await sdk.Playlist.ListPlaylistsAsync(req);

            // handle response
  - target: $["paths"]["/playlists"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            CreatePlaylistRequest req = new CreatePlaylistRequest() {};

            var res = await sdk.LibraryPlaylists.CreatePlaylistAsync(req);

            // handle response
  - target: $["paths"]["/playlists/upload"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            UploadPlaylistRequest req = new UploadPlaylistRequest() {
                Path = "/home/barkley/playlist.m3u",
                Force = BoolInt.One,
            };

            var res = await sdk.LibraryPlaylists.UploadPlaylistAsync(req);

            // handle response
  - target: $["paths"]["/playlists/{playlistId}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeletePlaylistRequest req = new DeletePlaylistRequest() {
                PlaylistId = 343293,
            };

            var res = await sdk.LibraryPlaylists.DeletePlaylistAsync(req);

            // handle response
  - target: $["paths"]["/playlists/{playlistId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetPlaylistRequest req = new GetPlaylistRequest() {
                PlaylistId = 841953,
            };

            var res = await sdk.Playlist.GetPlaylistAsync(req);

            // handle response
  - target: $["paths"]["/playlists/{playlistId}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            UpdatePlaylistRequest req = new UpdatePlaylistRequest() {
                PlaylistId = 157966,
            };

            var res = await sdk.LibraryPlaylists.UpdatePlaylistAsync(req);

            // handle response
  - target: $["paths"]["/playlists/{playlistId}/generators"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetPlaylistGeneratorsRequest req = new GetPlaylistGeneratorsRequest() {
                PlaylistId = 162342,
            };

            var res = await sdk.LibraryPlaylists.GetPlaylistGeneratorsAsync(req);

            // handle response
  - target: $["paths"]["/playlists/{playlistId}/items"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ClearPlaylistItemsRequest req = new ClearPlaylistItemsRequest() {
                PlaylistId = 552140,
            };

            var res = await sdk.LibraryPlaylists.ClearPlaylistItemsAsync(req);

            // handle response
  - target: $["paths"]["/playlists/{playlistId}/items"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetPlaylistItemsRequest req = new GetPlaylistItemsRequest() {
                PlaylistId = 118195,
            };

            var res = await sdk.Playlist.GetPlaylistItemsAsync(req);

            // handle response
  - target: $["paths"]["/playlists/{playlistId}/items"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            AddPlaylistItemsRequest req = new AddPlaylistItemsRequest() {
                PlaylistId = 533723,
            };

            var res = await sdk.LibraryPlaylists.AddPlaylistItemsAsync(req);

            // handle response
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeletePlaylistItemRequest req = new DeletePlaylistItemRequest() {
                PlaylistId = 981646,
                GeneratorId = 194010,
            };

            var res = await sdk.LibraryPlaylists.DeletePlaylistItemAsync(req);

            // handle response
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetPlaylistGeneratorRequest req = new GetPlaylistGeneratorRequest() {
                PlaylistId = 744880,
                GeneratorId = 322168,
            };

            var res = await sdk.LibraryPlaylists.GetPlaylistGeneratorAsync(req);

            // handle response
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}/items"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetPlaylistGeneratorItemsRequest req = new GetPlaylistGeneratorItemsRequest() {
                PlaylistId = 77230,
                GeneratorId = 979714,
            };

            var res = await sdk.LibraryPlaylists.GetPlaylistGeneratorItemsAsync(req);

            // handle response
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}/{metadataId}/{action}"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            RefreshPlaylistRequest req = new RefreshPlaylistRequest() {
                PlaylistId = 895314,
                GeneratorId = 629742,
                MetadataId = 724422,
                Action = Action.Disable,
            };

            var res = await sdk.LibraryPlaylists.RefreshPlaylistAsync(req);

            // handle response
  - target: $["paths"]["/playlists/{playlistId}/items/{playlistItemId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            MovePlaylistItemRequest req = new MovePlaylistItemRequest() {
                PlaylistId = 940298,
                PlaylistItemId = 375626,
            };

            var res = await sdk.LibraryPlaylists.MovePlaylistItemAsync(req);

            // handle response
  - target: $["paths"]["/security/resources"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetSourceConnectionInformationRequest req = new GetSourceConnectionInformationRequest() {
                Source = "<value>",
                Refresh = BoolInt.One,
            };

            var res = await sdk.General.GetSourceConnectionInformationAsync(req);

            // handle response
  - target: $["paths"]["/security/token"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetTransientTokenRequest req = new GetTransientTokenRequest() {
                Type = QueryParamType.Delegation,
                Scope = Scope.All,
            };

            var res = await sdk.General.GetTransientTokenAsync(req);

            // handle response
  - target: $["paths"]["/services/ultrablur/colors"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetColorsRequest req = new GetColorsRequest() {
                Url = "/library/metadata/217745/art/1718931408",
            };

            var res = await sdk.UltraBlur.GetColorsAsync(req);

            // handle response
  - target: $["paths"]["/services/ultrablur/image"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetImageRequest req = new GetImageRequest() {
                TopLeft = "3f280a",
                TopRight = "6b4713",
                BottomRight = "0f2a43",
                BottomLeft = "1c425d",
                Width = 1920,
                Height = 1080,
                Noise = BoolInt.One,
            };

            var res = await sdk.UltraBlur.GetImageAsync(req);

            // handle response
  - target: $["paths"]["/status/sessions"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Status.ListSessionsAsync();

            // handle response
  - target: $["paths"]["/status/sessions/background"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Status.GetBackgroundTasksAsync();

            // handle response
  - target: $["paths"]["/status/sessions/history/all"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;
            using System.Collections.Generic;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ListPlaybackHistoryRequest req = new ListPlaybackHistoryRequest() {
                Sort = new List<string>() {
                    "v",
                    "i",
                    "e",
                    "w",
                    "e",
                    "d",
                    "A",
                    "t",
                    ":",
                    "d",
                    "e",
                    "s",
                    "c",
                    ",",
                    "a",
                    "c",
                    "c",
                    "o",
                    "u",
                    "n",
                    "t",
                    "I",
                    "D",
                },
            };

            var res = await sdk.Status.ListPlaybackHistoryAsync(req);

            // handle response
  - target: $["paths"]["/status/sessions/history/{historyId}"]["delete"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            DeleteHistoryRequest req = new DeleteHistoryRequest() {
                HistoryId = 953579,
            };

            var res = await sdk.Status.DeleteHistoryAsync(req);

            // handle response
  - target: $["paths"]["/status/sessions/history/{historyId}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            GetHistoryItemRequest req = new GetHistoryItemRequest() {
                HistoryId = 832213,
            };

            var res = await sdk.Status.GetHistoryItemAsync(req);

            // handle response
  - target: $["paths"]["/status/sessions/terminate"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            TerminateSessionRequest req = new TerminateSessionRequest() {
                SessionId = "cdefghijklmnopqrstuvwxyz",
                Reason = "Stop Playing",
            };

            var res = await sdk.Status.TerminateSessionAsync(req);

            // handle response
  - target: $["paths"]["/updater/apply"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            ApplyUpdatesRequest req = new ApplyUpdatesRequest() {
                Tonight = BoolInt.One,
                Skip = BoolInt.One,
            };

            var res = await sdk.Updater.ApplyUpdatesAsync(req);

            // handle response
  - target: $["paths"]["/updater/check"]["put"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            CheckUpdatesRequest req = new CheckUpdatesRequest() {
                Download = BoolInt.One,
            };

            var res = await sdk.Updater.CheckUpdatesAsync(req);

            // handle response
  - target: $["paths"]["/updater/status"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;

            var sdk = new PlexAPI(token: "<YOUR_API_KEY_HERE>");

            var res = await sdk.Updater.GetUpdatesStatusAsync();

            // handle response
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/decision"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            MakeDecisionRequest req = new MakeDecisionRequest() {
                TranscodeType = TranscodeType.Music,
                AdvancedSubtitles = LukeHagar.PlexAPI.SDK.Models.Components.AdvancedSubtitles.Burn,
                AudioBoost = 50,
                AudioChannelCount = 5,
                AutoAdjustQuality = BoolInt.One,
                AutoAdjustSubtitle = BoolInt.One,
                DirectPlay = BoolInt.One,
                DirectStream = BoolInt.One,
                DirectStreamAudio = BoolInt.One,
                DisableResolutionRotation = BoolInt.One,
                HasMDE = BoolInt.One,
                Location = LukeHagar.PlexAPI.SDK.Models.Requests.Location.Wan,
                MediaBufferSize = 102400,
                MediaIndex = 0,
                MusicBitrate = 5000,
                Offset = 90.5D,
                PartIndex = 0,
                Path = "/library/metadata/151671",
                PeakBitrate = 12000,
                PhotoResolution = "1080x1080",
                Protocol = LukeHagar.PlexAPI.SDK.Models.Requests.Protocol.Dash,
                SecondsPerSegment = 5,
                SubtitleSize = 50,
                VideoBitrate = 12000,
                VideoQuality = 50,
                VideoResolution = "1080x1080",
                XPlexClientProfileExtra = "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 = "generic",
            };

            var res = await sdk.Transcoder.MakeDecisionAsync(req);

            // handle response
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/fallback"]["post"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            TriggerFallbackRequest req = new TriggerFallbackRequest() {
                TranscodeType = TranscodeType.Audio,
            };

            var res = await sdk.Transcoder.TriggerFallbackAsync(req);

            // handle response
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/start.{extension}"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            StartTranscodeSessionRequest req = new StartTranscodeSessionRequest() {
                TranscodeType = TranscodeType.Music,
                Extension = Extension.Mpd,
                AdvancedSubtitles = LukeHagar.PlexAPI.SDK.Models.Components.AdvancedSubtitles.Burn,
                AudioBoost = 50,
                AudioChannelCount = 5,
                AutoAdjustQuality = BoolInt.One,
                AutoAdjustSubtitle = BoolInt.One,
                DirectPlay = BoolInt.One,
                DirectStream = BoolInt.One,
                DirectStreamAudio = BoolInt.One,
                DisableResolutionRotation = BoolInt.One,
                HasMDE = BoolInt.One,
                Location = StartTranscodeSessionQueryParamLocation.Wan,
                MediaBufferSize = 102400,
                MediaIndex = 0,
                MusicBitrate = 5000,
                Offset = 90.5D,
                PartIndex = 0,
                Path = "/library/metadata/151671",
                PeakBitrate = 12000,
                PhotoResolution = "1080x1080",
                Protocol = StartTranscodeSessionQueryParamProtocol.Dash,
                SecondsPerSegment = 5,
                SubtitleSize = 50,
                VideoBitrate = 12000,
                VideoQuality = 50,
                VideoResolution = "1080x1080",
                XPlexClientProfileExtra = "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 = "generic",
            };

            var res = await sdk.Transcoder.StartTranscodeSessionAsync(req);

            // handle response
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/subtitles"]["get"]
    update:
      x-codeSamples:
        - lang: csharp
          label: PlexCSharp
          source: |-
            using LukeHagar.PlexAPI.SDK;
            using LukeHagar.PlexAPI.SDK.Models.Components;
            using LukeHagar.PlexAPI.SDK.Models.Requests;

            var sdk = new PlexAPI(
                accepts: LukeHagar.PlexAPI.SDK.Models.Components.Accepts.ApplicationXml,
                clientIdentifier: "abc123",
                product: "Plex for Roku",
                version: "2.4.1",
                platform: "Roku",
                platformVersion: "4.3 build 1057",
                device: "Roku 3",
                model: "4200X",
                deviceVendor: "Roku",
                deviceName: "Living Room TV",
                marketplace: "googlePlay",
                token: "<YOUR_API_KEY_HERE>"
            );

            TranscodeSubtitlesRequest req = new TranscodeSubtitlesRequest() {
                TranscodeType = TranscodeType.Audio,
                AdvancedSubtitles = LukeHagar.PlexAPI.SDK.Models.Components.AdvancedSubtitles.Burn,
                AudioBoost = 50,
                AudioChannelCount = 5,
                AutoAdjustQuality = BoolInt.One,
                AutoAdjustSubtitle = BoolInt.One,
                DirectPlay = BoolInt.One,
                DirectStream = BoolInt.One,
                DirectStreamAudio = BoolInt.One,
                DisableResolutionRotation = BoolInt.One,
                HasMDE = BoolInt.One,
                Location = QueryParamLocation.Wan,
                MediaBufferSize = 102400,
                MediaIndex = 0,
                MusicBitrate = 5000,
                Offset = 90.5D,
                PartIndex = 0,
                Path = "/library/metadata/151671",
                PeakBitrate = 12000,
                PhotoResolution = "1080x1080",
                Protocol = QueryParamProtocol.Dash,
                SecondsPerSegment = 5,
                SubtitleSize = 50,
                VideoBitrate = 12000,
                VideoQuality = 50,
                VideoResolution = "1080x1080",
                XPlexClientProfileExtra = "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 = "generic",
            };

            var res = await sdk.Transcoder.TranscodeSubtitlesAsync(req);

            // handle response