codeSamples.yaml

overlay: 1.0.0
info:
  title: CodeSamples overlay for typescript target
  version: 0.0.0
actions:
  - target: $["paths"]["/"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getServerInfo({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/:/eventsource/notifications"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.events.getNotifications({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/:/prefs"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.preferences.getAllPreferences();

              console.log(result);
            }

            run();
  - target: $["paths"]["/:/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.preferences.setPreferences({
                prefs: {},
              });


            }

            run();
  - target: $["paths"]["/:/prefs/get"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.preferences.getPreference({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/:/progress"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.getProgress({
                key: "<key>",
                time: 181086,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/:/rate"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.rate.setRating({
                identifier: "<value>",
                key: "<key>",
                rating: 8722.46,
              });


            }

            run();
  - target: $["paths"]["/:/scrobble"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.timeline.markPlayed({
                identifier: "<value>",
                key: "59398",
                uri: "https://mad-dredger.name",
              });


            }

            run();
  - target: $["paths"]["/:/timeline"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { ReportState } from "@parke.dev/plexjs/models/operations";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.timeline.report({
                key: "/foo",
                ratingKey: "xyz",
                state: ReportState.Playing,
                playQueueItemID: "123",
                time: 0,
                duration: 10000,
                continuing: BoolInt.True,
                updated: 14200000,
                offline: BoolInt.True,
                timeToFirstFrame: 1000,
                timeStalled: 1000,
                bandwidth: 100,
                bufferedTime: 100,
                bufferedSize: 1024,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/:/unscrobble"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.timeline.unscrobble({
                identifier: "<value>",
                uri: "https://qualified-order.org",
              });


            }

            run();
  - target: $["paths"]["/:/websocket/notifications"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.events.connectWebSocket({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/:/websockets/notifications"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.events.getWebsocketNotifications({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/accounts"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getSystemAccounts({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/actions/addToWatchlist"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.provider.addToWatchlist({
                uri: "https://frightened-duster.com/",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/actions/removeFromContinueWatching"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.removeFromContinueWatching({
                key: "<key>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/actions/removeFromWatchlist"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.provider.removeFromWatchlist({
                uri: "https://miserable-scrap.net",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/activities"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.activities.listActivities();

              console.log(result);
            }

            run();
  - target: $["paths"]["/activities/{activityId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.activities.cancelActivity({
                activityId: "d6199ba1-fb5e-4cae-bf17-1a5369c1cf1e",
              });


            }

            run();
  - target: $["paths"]["/api/invites/requests/{inviteId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.acceptInvite({
                inviteId: 530502,
                friend: BoolInt.True,
                home: BoolInt.True,
                server: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/api/resources"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.users.getLegacyResources();

              console.log(result);
            }

            run();
  - target: $["paths"]["/api/users/"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.users.getLegacyUsers();

              console.log(result);
            }

            run();
  - target: $["paths"]["/api/v2/user/webhooks"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.general.getUserWebhooks();

              console.log(result);
            }

            run();
  - target: $["paths"]["/api/v2/user/webhooks"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.addUserWebhook({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/auth/jwk"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.authentication.registerDeviceJWK({
                jwkRegistrationRequest: {
                  jwk: {
                    crv: "string value",
                    kid: "string value",
                    kty: "string value",
                    x: "string value",
                  },
                },
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/auth/keys"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.authentication.getAuthKeys({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/auth/nonce"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.authentication.getAuthNonce({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/auth/token"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.authentication.exchangeJWTToken({
                tokenExchangeRequest: {
                  clientIdentifier: "string value",
                  jwt: "string value",
                  scope: "string value",
                },
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/butler"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              await plexAPI.butler.stopTasks();


            }

            run();
  - target: $["paths"]["/butler"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.butler.getTasks();

              console.log(result);
            }

            run();
  - target: $["paths"]["/butler"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              await plexAPI.butler.startTasks();


            }

            run();
  - target: $["paths"]["/butler/{butlerTask}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { StopTaskButlerTask } from "@parke.dev/plexjs/models/operations";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.butler.stopTask({
                butlerTask: StopTaskButlerTask.CleanOldBundles,
              });


            }

            run();
  - target: $["paths"]["/butler/{butlerTask}"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { StartTaskButlerTask } from "@parke.dev/plexjs/models/operations";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.butler.startTask({
                butlerTask: StartTaskButlerTask.RefreshLocalMedia,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/claim/token.json"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.authentication.getClaimToken({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/clients"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getClients({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/cloud_server"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getCloudServer({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/devices"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getSystemDevices({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/diagnostics"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getDiagnostics({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/diagnostics/databases"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.downloadDatabaseDiagnostics({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/diagnostics/logs"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.downloadLogBundle({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/downloadQueue"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.downloadQueue.createDownloadQueue();

              console.log(result);
            }

            run();
  - target: $["paths"]["/downloadQueue/{queueId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.downloadQueue.getDownloadQueue({
                queueId: 922802,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/downloadQueue/{queueId}/add"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import {
              Accepts,
              AdvancedSubtitles,
              BoolInt,
              LocationParameter,
              ProtocolParameter,
              Subtitles,
            } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.downloadQueue.addDownloadQueueItems({
                advancedSubtitles: AdvancedSubtitles.Burn,
                audioBoost: 50,
                audioChannelCount: 5,
                autoAdjustQuality: BoolInt.True,
                autoAdjustSubtitle: BoolInt.True,
                directPlay: BoolInt.True,
                directStream: BoolInt.True,
                directStreamAudio: BoolInt.True,
                disableResolutionRotation: BoolInt.True,
                hasMDE: BoolInt.True,
                location: LocationParameter.Wan,
                mediaBufferSize: 102400,
                mediaIndex: 0,
                musicBitrate: 5000,
                offset: 90.5,
                partIndex: 0,
                path: "/library/metadata/151671",
                peakBitrate: 12000,
                photoResolution: "1080x1080",
                protocol: ProtocolParameter.Dash,
                secondsPerSegment: 5,
                subtitleSize: 50,
                subtitles: Subtitles.Burn,
                videoBitrate: 12000,
                videoQuality: 50,
                videoResolution: "1080x1080",
                queueId: 984925,
                keys: [
                  "/library/metadata/3",
                  "/library/metadata/6",
                ],
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/downloadQueue/{queueId}/item/{itemId}/decision"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.downloadQueue.getItemDecision({
                queueId: 231605,
                itemId: 32,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/downloadQueue/{queueId}/item/{itemId}/media"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.downloadQueue.getDownloadQueueMedia({
                queueId: 663184,
                itemId: 32,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/downloadQueue/{queueId}/items"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.downloadQueue.listDownloadQueueItems({
                queueId: 524138,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/downloadQueue/{queueId}/items/{itemId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.downloadQueue.removeDownloadQueueItems({
                queueId: 946275,
                itemId: [
                  32,
                  345,
                  23,
                ],
              });


            }

            run();
  - target: $["paths"]["/downloadQueue/{queueId}/items/{itemId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.downloadQueue.getDownloadQueueItems({
                queueId: 809886,
                itemId: [
                  32,
                  345,
                  23,
                ],
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/downloadQueue/{queueId}/items/{itemId}/restart"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.downloadQueue.restartProcessingDownloadQueueItems({
                queueId: 713001,
                itemId: [
                  32,
                  345,
                  23,
                ],
              });


            }

            run();
  - target: $["paths"]["/downloads/{channel}.json"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getPlexDownloads({
                channel: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/features"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.authentication.getFeatures();

              console.log(result);
            }

            run();
  - target: $["paths"]["/friends"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.getFriends({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/geoip"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getGeoIP({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/home"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.users.getHome();

              console.log(result);
            }

            run();
  - target: $["paths"]["/home/users"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.getHomeUsers({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/home/users"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.createHomeUser({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/home/users/restricted/{userId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.updateRestrictedUser({
                userId: 130660,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/home/users/{id}/switch"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.authentication.switchHomeUser({
                id: 135337,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/home/users/{userId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.deleteHomeUser({
                userId: 768153,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/home/users/{userId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.updateHomeUser({
                userId: 187897,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.hubs.getAllHubs({
                onlyTransient: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/continueWatching"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.hubs.getContinueWatching({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/continueWatching/items"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.hubs.getContinueWatchingItems({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/home/recentlyAdded"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.hubs.getHomeRecentlyAdded({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/items"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.hubs.getHubItems({
                identifier: [
                  "<value 1>",
                  "<value 2>",
                  "<value 3>",
                ],
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/metadata/{metadataId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.hubs.getMetadataHubs({
                metadataId: 605482,
                onlyTransient: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/metadata/{metadataId}/postplay"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.hubs.getPostplayHubs({
                metadataId: 441419,
                onlyTransient: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/metadata/{metadataId}/related"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.hubs.getRelatedHubs({
                metadataId: 8858,
                onlyTransient: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/promoted"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.hubs.getPromotedHubs({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/search"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.search.searchHubs({
                query: "<value>",
                sectionId: 1,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/search/voice"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, MediaType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.search.voiceSearchHubs({
                type: MediaType.TvShow,
                query: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/sections/{sectionId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.hubs.getSectionHubs({
                sectionId: 336924,
                onlyTransient: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/sections/{sectionId}/manage"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.hubs.resetSectionDefaults({
                sectionId: 383022,
              });


            }

            run();
  - target: $["paths"]["/hubs/sections/{sectionId}/manage"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.hubs.listHubs({
                sectionId: 442546,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/sections/{sectionId}/manage"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.hubs.createCustomHub({
                sectionId: 869922,
                metadataItemId: 703843,
                promotedToRecommended: BoolInt.True,
                promotedToOwnHome: BoolInt.True,
                promotedToSharedHome: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/hubs/sections/{sectionId}/manage/move"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.hubs.moveHub({
                sectionId: 755710,
                identifier: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/hubs/sections/{sectionId}/manage/{identifier}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.hubs.deleteCustomHub({
                sectionId: 625677,
                identifier: "<value>",
              });


            }

            run();
  - target: $["paths"]["/hubs/sections/{sectionId}/manage/{identifier}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.hubs.updateHubVisibility({
                sectionId: 341650,
                identifier: "<value>",
                promotedToRecommended: BoolInt.True,
                promotedToOwnHome: BoolInt.True,
                promotedToSharedHome: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/identity"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI();

            async function run() {
              const result = await plexAPI.general.getIdentity();

              console.log(result);
            }

            run();
  - target: $["paths"]["/ip"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getIP({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/library"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.library.getRootLibrary();

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/all"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, MediaType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getLibraryItems({
                mediaQuery: {
                  type: MediaType.Episode,
                  sort: "duration:desc,index",
                  sourceType: 2,
                },
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/caches"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              await plexAPI.library.deleteCaches();


            }

            run();
  - target: $["paths"]["/library/clean/bundles"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              await plexAPI.library.cleanBundles();


            }

            run();
  - target: $["paths"]["/library/collections"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, MediaType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.collections.createCollection({
                type: MediaType.TvShow,
                sectionId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/collections/{collectionId}/composite/{updatedAt}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.content.getCollectionImage({
                collectionId: 474227,
                updatedAt: 759379,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/collections/{collectionId}/items"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.content.getCollectionItems({
                collectionId: 314585,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/collections/{collectionId}/items"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.libraryCollections.addCollectionItems({
                collectionId: 338144,
                uri: "https://expensive-bakeware.com",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/collections/{collectionId}/items/{itemId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.libraryCollections.updateCollectionItem({
                collectionId: 640014,
                itemId: 2136,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/collections/{collectionId}/items/{itemId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.libraryCollections.moveCollectionItem({
                collectionId: 239532,
                itemId: 513864,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/file"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.ingestTransientItem({
                url: "file:///storage%2Femulated%2F0%2FArcher-S01E01.mkv",
                virtualFilePath: "/Avatar.mkv",
                computeHashes: BoolInt.True,
                ingestNonMatches: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/matches"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt, MediaType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getLibraryMatches({
                type: MediaType.TvShow,
                includeFullMetadata: BoolInt.True,
                includeAncestorMetadata: BoolInt.True,
                includeAlternateMetadataSources: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/media/{mediaId}/chapterImages/{chapter}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getChapterImage({
                mediaId: 892563,
                chapter: 48348,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/augmentations/{augmentationId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.getAugmentationStatus({
                augmentationId: "<id>",
                wait: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.deleteMetadataItem({
                ids: "<value>",
                proxy: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.content.getMetadataItem({
                ids: [],
                asyncCheckFiles: BoolInt.True,
                asyncRefreshLocalMediaAgent: BoolInt.True,
                asyncRefreshAnalysis: BoolInt.True,
                checkFiles: BoolInt.True,
                skipRefresh: BoolInt.True,
                checkFileAvailability: BoolInt.True,
                asyncAugmentMetadata: BoolInt.True,
                augmentCount: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{ids}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.editMetadataItem({
                ids: [
                  "<value 1>",
                  "<value 2>",
                ],
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/addetect"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.detectAds({
                ids: "<value>",
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/allLeaves"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getAllItemLeaves({
                ids: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/analyze"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.analyzeMetadata({
                ids: "<value>",
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/chapterThumbs"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.generateThumbs({
                ids: "<value>",
                force: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/credits"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.detectCredits({
                ids: "<value>",
                force: BoolInt.True,
                manual: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/extras"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getExtras({
                ids: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/extras"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.addExtras({
                ids: "<value>",
                url: "https://super-mortise.biz/",
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/file"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getFile({
                ids: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/index"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.startBifGeneration({
                ids: "<value>",
                force: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/intro"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.detectIntros({
                ids: "<value>",
                force: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/marker"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.createMarker({
                ids: "<value>",
                mediaType: 248391,
                startTimeOffset: 535191,
                attributes: {},
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/marker/{marker}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.deleteMarker({
                ids: "<value>",
                marker: "<value>",
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/marker/{marker}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.editMarker({
                ids: "<value>",
                marker: "<value>",
                mediaType: 884347,
                startTimeOffset: 517251,
                attributes: {},
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/match"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.matchItem({
                ids: "<value>",
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/matches"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.listMatches({
                ids: "<value>",
                manual: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/media/{mediaItem}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.deleteMediaItem({
                ids: "<value>",
                mediaItem: "<value>",
                proxy: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/merge"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.mergeItems({
                idsPathParameter: "<value>",
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.setItemPreferences({
                ids: "<value>",
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/refresh"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.refreshItemsMetadata({
                ids: "<value>",
                markUpdated: BoolInt.True,
                skipRefresh: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/related"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getRelatedItems({
                ids: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/similar"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.listSimilar({
                ids: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/split"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.splitItem({
                ids: "<value>",
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/subtitles"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.getSubtitles({
                ids: "<value>",
                forced: BoolInt.True,
                hearingImpaired: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/tree"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getItemTree({
                ids: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/unmatch"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.unmatch({
                ids: "<value>",
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/users/top"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.listTopUsers({
                ids: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/voiceActivity"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.detectVoiceActivity({
                ids: "<value>",
                force: BoolInt.True,
                manual: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/{element}"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { SetItemArtworkElement } from "@parke.dev/plexjs/models/operations";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.setItemArtwork({
                ids: "<value>",
                element: SetItemArtworkElement.Banner,
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/{element}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { UpdateItemArtworkElement } from "@parke.dev/plexjs/models/operations";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.updateItemArtwork({
                ids: "<value>",
                element: UpdateItemArtworkElement.ClearLogo,
              });


            }

            run();
  - target: $["paths"]["/library/metadata/{ids}/{element}/{timestamp}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { GetItemArtworkElement } from "@parke.dev/plexjs/models/operations";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getItemArtwork({
                ids: "<value>",
                element: GetItemArtworkElement.Poster,
                timestamp: 999555,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{id}/arts"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";
            import { openAsBlob } from "node:fs";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.uploadArt({
                id: 996758,
                requestBody: {
                  file: await openAsBlob("example.file"),
                },
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{id}/children"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getMetadataChildren({
                includeMeta: BoolInt.True,
                id: 240367,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{id}/computePath"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.computeSonicPath({
                id: 622554,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{id}/grandchildren"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getMetadataGrandchildren({
                id: 679910,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{id}/grandparent"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getMetadataGrandparent({
                id: 191152,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{id}/nearest"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getNearestMetadata({
                id: 62697,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{id}/onDeck"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getMetadataOnDeck({
                id: 883975,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{id}/parent"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getMetadataParent({
                id: 352555,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{id}/posters"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";
            import { openAsBlob } from "node:fs";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.uploadPoster({
                id: 316927,
                requestBody: {
                  file: await openAsBlob("example.file"),
                },
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/metadata/{id}/reviews"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getMetadataReviews({
                id: 146091,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/optimize"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.optimizeLibrary({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/optimize"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.optimizeLibraryPost({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/optimize"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.optimizeDatabase({
                async: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/parts/{partId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.setStreamSelection({
                partId: 360489,
                allParts: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/parts/{partId}/indexes/{index}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { GetPartIndexIndex } from "@parke.dev/plexjs/models/operations";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getPartIndex({
                partId: 724750,
                index: GetPartIndexIndex.Sd,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/parts/{partId}/indexes/{index}/{offset}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { GetImageFromBifIndex } from "@parke.dev/plexjs/models/operations";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getImageFromBif({
                partId: 304273,
                index: GetImageFromBifIndex.Sd,
                offset: 939569,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/parts/{partId}/{changestamp}/{filename}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getMediaPart({
                partId: 877105,
                changestamp: 970622,
                filename: "example.file",
                download: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/people/{personId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getPerson({
                personId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/people/{personId}/media"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.listPersonMedia({
                personId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/randomArtwork"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getRandomArtwork({
                sections: [
                  5,
                  6,
                ],
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/recentlyAdded"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getRecentlyAddedGlobal({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/search"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.provider.searchDiscover({
                searchTypes: "movies,tv",
                searchProviders: "discover,PLEXAVOD,PLEXTVOD",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.library.getLibrarySectionsFallback();

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/all"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.library.getSections();

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/all"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.addSection({
                name: "<value>",
                mediaType: 39544,
                agent: "<value>",
                language: "<value>",
                locations: [
                  "O:\\fatboy\\Media\\Ripped\\Music",
                  "O:\\fatboy\\Media\\My Music",
                ],
                prefs: {},
                relative: BoolInt.True,
                importFromiTunes: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/all/refresh"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.library.stopAllRefreshes();

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/prefs"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionsPrefs({
                mediaType: 460221,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/refresh"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.refreshSectionsMetadata({});


            }

            run();
  - target: $["paths"]["/library/sections/watchlist/all"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.provider.getWatchlist({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.deleteLibrarySection({
                sectionId: "<id>",
                async: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getLibraryDetails({
                sectionId: "<id>",
                includeDetails: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.editSection({
                sectionId: "<id>",
                agent: "<value>",
                locations: [
                  "O:\\fatboy\\Media\\Ripped\\Music",
                  "O:\\fatboy\\Media\\My Music",
                ],
                prefs: {},
              });


            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/agents"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionAgents({
                sectionId: 757906,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/albums"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.content.getAlbums({
                sectionId: 817133,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/all"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt, MediaType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.content.listContent({
                pmsApiVersion: "1.0",
                mediaQuery: {
                  type: MediaType.Episode,
                  sort: "duration:desc,index",
                  sourceType: 2,
                },
                sectionId: 813218,
                updatedAtAfter: 1792000000,
                updatedAtBefore: 1792054845,
                addedAtAfter: 1791200000,
                addedAtBefore: 1791252847,
                includeMeta: BoolInt.True,
                includeGuids: BoolInt.True,
                includeCollections: BoolInt.True,
                includeExternalMedia: BoolInt.True,
                includeAdvanced: BoolInt.True,
                checkFiles: BoolInt.True,
                includeRelated: BoolInt.True,
                includeExtras: BoolInt.True,
                includePopularLeaves: BoolInt.True,
                includeConcerts: BoolInt.True,
                includeOnDeck: BoolInt.True,
                includeChapters: BoolInt.True,
                includePreferences: BoolInt.True,
                includeBandwidths: BoolInt.True,
                includeLoudnessRamps: BoolInt.True,
                includeStations: BoolInt.True,
                includeExternalIds: BoolInt.True,
                includeReviews: BoolInt.True,
                includeCredits: BoolInt.True,
                includeArt: BoolInt.True,
                includeThumb: BoolInt.True,
                includeBanner: BoolInt.True,
                includeTheme: BoolInt.True,
                includeFields: "ratingKey,updatedAt,size,totalSize,offset",
                asyncAugmentMetadata: BoolInt.True,
                asyncRefreshLocalMediaAgent: BoolInt.True,
                nocache: BoolInt.True,
                skipRefresh: BoolInt.True,
                includeOptionalElements: "Stream",
                unwatched: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/all"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.updateItems({
                sectionId: "<id>",
                fieldLocked: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/allLeaves"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.content.getAllLeaves({
                sectionId: 633197,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/analyze"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.startAnalysis({
                sectionId: 158829,
              });


            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/artists"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionArtists({
                sectionId: 716398,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/arts"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.content.getArts({
                sectionId: 859200,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/autocomplete"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, MediaType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.autocomplete({
                mediaQuery: {
                  type: MediaType.Episode,
                  sort: "duration:desc,index",
                  sourceType: 2,
                },
                sectionId: 942007,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/byContentRating"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getByContentRating({
                sectionId: 586837,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/byDecade"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getByDecade({
                sectionId: 212187,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/byFolder"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getByFolder({
                sectionId: 352088,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/byResolution"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getByResolution({
                sectionId: 139174,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/byYear"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getByYear({
                sectionId: 14634,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/categories"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.content.getCategories({
                sectionId: 21841,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/clips"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionClips({
                sectionId: 407860,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/cluster"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.content.getCluster({
                sectionId: 138560,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/collection/{collectionId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.deleteCollection({
                sectionId: 283619,
                collectionId: 680895,
              });


            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/collections"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, MediaType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getCollections({
                mediaQuery: {
                  type: MediaType.Episode,
                  sort: "duration:desc,index",
                  sourceType: 2,
                },
                sectionId: 348838,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/common"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, MediaType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getCommon({
                mediaQuery: {
                  type: MediaType.Episode,
                  sort: "duration:desc,index",
                  sourceType: 2,
                },
                sectionId: 298154,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/composite/{updatedAt}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, MediaType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.getSectionImage({
                mediaQuery: {
                  type: MediaType.Episode,
                  sort: "duration:desc,index",
                  sourceType: 2,
                },
                sectionId: 925611,
                updatedAt: 117413,
              });


            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/computePath"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.content.getSonicPath({
                sectionId: 914549,
                startID: 629990,
                endID: 687740,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/edit"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionEdit({
                sectionId: 223075,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/edit"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.editLibrarySection({
                sectionId: 834094,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/emptyTrash"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.emptyTrash({
                sectionId: 30052,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/emptyTrash"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.emptyTrashPost({
                sectionId: 537157,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/emptyTrash"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.emptyTrashPut({
                sectionId: 642296,
              });


            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/episodes"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionEpisodes({
                sectionId: 229495,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/filters"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionFilters({
                sectionId: 380557,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/firstCharacters"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, MediaType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getFirstCharacters({
                mediaQuery: {
                  type: MediaType.Episode,
                  sort: "duration:desc,index",
                  sourceType: 2,
                },
                sectionId: 3947,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/folder"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: Accepts.ApplicationXml,
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionFolder({
                sectionId: 924129,
                parent: "3706",
                includeMeta: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/hubs"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getLibrarySectionHubs({
                sectionId: 426468,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/indexes"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.deleteIndexes({
                sectionId: 588437,
              });


            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/intros"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.deleteIntros({
                sectionId: 498656,
              });


            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/label"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionLabels({
                sectionId: 705342,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/location"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.content.getFolders({
                sectionId: 892532,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/match"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.matchSectionItems({
                sectionId: 31032,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/moment"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.content.listMoments({
                sectionId: 403239,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.moveSection({
                sectionId: 483061,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/movies"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionMovies({
                sectionId: 530892,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/nearest"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.content.getSonicallySimilar({
                sectionId: 525956,
                values: [],
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/newest"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getNewestForSection({
                sectionId: 73900,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/onDeck"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getOnDeckForSection({
                sectionId: 331089,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/optimize"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.optimizeSection({
                sectionId: 721290,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/optimize"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.optimizeSectionPost({
                sectionId: 876391,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/photos"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionPhotos({
                sectionId: 622466,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/playlists"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionPlaylists({
                sectionId: 826184,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/prefs"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionPreferences({
                sectionId: 754869,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.setSectionPreferences({
                sectionId: 349936,
                prefs: {},
              });


            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/recentlyAdded"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getRecentlyAddedForSection({
                sectionId: 46283,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/refresh"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.cancelRefresh({
                sectionId: 326852,
              });


            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/refresh"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.refreshSection({
                sectionId: 450300,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/refresh"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.refreshSectionPost({
                sectionId: 848668,
                force: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/search"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.searchSection({
                sectionId: 925380,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/settings"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionSettings({
                sectionId: 100390,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/shows"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionShows({
                sectionId: 9583,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/sorts"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getAvailableSorts({
                sectionId: 212498,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/tags"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionTags({
                sectionId: 787543,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/timeline"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getSectionTimeline({
                sectionId: 670370,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/unmatch"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.unmatchSectionItems({
                sectionId: 209342,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/sections/{sectionId}/unwatched"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getUnwatchedForSection({
                sectionId: 483590,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/streams/{streamId}.{ext}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.library.deleteStream({
                streamId: 841510,
                ext: "<value>",
              });


            }

            run();
  - target: $["paths"]["/library/streams/{streamId}.{ext}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getStream({
                streamId: 314506,
                ext: "<value>",
                autoAdjustSubtitle: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/streams/{streamId}.{ext}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.setStreamOffset({
                streamId: 606295,
                ext: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/streams/{streamId}/levels"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getStreamLevels({
                streamId: 447611,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/streams/{streamId}/loudness"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getStreamLoudness({
                streamId: 277271,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/library/tags"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, MediaType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.library.getTags({
                type: MediaType.TvShow,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.dvRs.listDVRs();

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.dvRs.createDVR({
                lineup: "lineup://tv.plex.providers.epg.onconnect/USA-HI51418-DEFAULT",
                deviceQueryParameter: [
                  "device://tv.plex.grabbers.hdhomerun/1053C0CA",
                ],
                language: "eng",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.dvRs.deleteDVR({
                dvrId: 855088,
              });


            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.dvRs.getDVR({
                dvrId: 973518,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}"]["patch"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.dvRs.patchDVRSettings({
                dvrId: 537061,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.dvRs.updateDVRSettings({
                dvrId: 614847,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}/channels"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.dvRs.getDVRChannels({
                dvrId: 901521,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}/channels/{channel}/tune"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.dvRs.tuneChannel({
                dvrId: 834281,
                channel: "2.1",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}/devices/{deviceId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.dvRs.removeDeviceFromDVR({
                dvrId: 945416,
                deviceId: 260761,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}/devices/{deviceId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.dvRs.addDeviceToDVR({
                dvrId: 334755,
                deviceId: 852930,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}/guide"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.dvRs.getDVRGuide({
                dvrId: 19054,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}/lineups"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.dvRs.deleteLineup({
                dvrId: 454470,
                lineup: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}/lineups"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.dvRs.addLineup({
                dvrId: 945235,
                lineup: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.dvRs.setDVRPreferences({
                dvrId: 116357,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}/recordings"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.liveTV.getDVRRecordingsByDVR({
                dvrId: 83756,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}/reloadGuide"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.dvRs.stopDVRReload({
                dvrId: 348053,
              });


            }

            run();
  - target: $["paths"]["/livetv/dvrs/{dvrId}/reloadGuide"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.dvRs.reloadGuide({
                dvrId: 140753,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/epg/channelmap"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.epg.computeChannelMap({
                deviceQueryParameter: "Mobile",
                lineup: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/epg/channels"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.epg.getChannels({
                lineup: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/epg/countries"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.epg.getCountries();

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/epg/countries/{country}/{epgId}/lineups"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.epg.getCountriesLineups({
                country: "Malawi",
                epgId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/epg/countries/{country}/{epgId}/regions"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.epg.getCountryRegions({
                country: "Morocco",
                epgId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/epg/countries/{country}/{epgId}/regions/{region}/lineups"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.epg.listLineups({
                country: "Vanuatu",
                epgId: "<id>",
                region: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/epg/guide"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.epg.getEPGGuide();

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/epg/languages"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.epg.getAllLanguages();

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/epg/lineup"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.epg.getLineup({
                deviceQueryParameter: "Desktop",
                lineupGroup: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/epg/lineupchannels"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.epg.getLineupChannels({
                lineup: [
                  "<value 1>",
                  "<value 2>",
                ],
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/epg/search"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.epg.searchEPG({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/recordings"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.liveTV.getDVRRecordings({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/sessions"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.liveTV.getSessions();

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/sessions/{sessionId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.liveTV.deleteLiveTVSession({
                sessionId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/sessions/{sessionId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.liveTV.getLiveTVSession({
                sessionId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/sessions/{sessionId}/{consumerId}/index.m3u8"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.liveTV.getSessionPlaylistIndex({
                sessionId: "<id>",
                consumerId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/livetv/sessions/{sessionId}/{consumerId}/{segmentId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.liveTV.getSessionSegment({
                sessionId: "<id>",
                consumerId: "<id>",
                segmentId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/log"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { openAsBlob } from "node:fs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              await plexAPI.log.writeLog(await openAsBlob("example.file"));


            }

            run();
  - target: $["paths"]["/log"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.log.writeMessage({});


            }

            run();
  - target: $["paths"]["/log/networked"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.log.enablePapertrail({});


            }

            run();
  - target: $["paths"]["/media/grabbers"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.devices.getAvailableGrabbers({
                protocol: "livetv",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/grabbers/devices"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.devices.listDevices();

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/grabbers/devices"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.devices.addDevice({
                uri: "http://10.0.0.5",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/grabbers/devices/discover"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.devices.discoverDevices();

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/grabbers/devices/{deviceId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.devices.removeDevice({
                deviceId: 685908,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/grabbers/devices/{deviceId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.devices.getDeviceDetails({
                deviceId: 170949,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/grabbers/devices/{deviceId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.devices.modifyDevice({
                deviceId: 879135,
                enabled: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/channelmap"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.devices.setChannelmap({
                deviceId: 937661,
                channelMapping: {},
                channelMappingByKey: {},
                channelsEnabled: [
                  "46.1",
                  "44.1",
                  "45.1",
                ],
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/channels"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.devices.getDevicesChannels({
                deviceId: 517209,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.devices.setDevicePreferences({
                deviceId: 420973,
              });


            }

            run();
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/scan"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.devices.stopScan({
                deviceId: 576494,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/scan"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.devices.scan({
                deviceId: 57391,
                source: "Cable",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/thumb/{version}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.devices.getThumb({
                deviceId: 960617,
                versionPathParameter: 1025,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/grabbers/operations/{operationId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.subscriptions.cancelGrab({
                operationId: "<id>",
              });


            }

            run();
  - target: $["paths"]["/media/providers"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.provider.listProviders();

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/providers"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.provider.addProvider({
                url: "https://steep-obedience.name/",
              });


            }

            run();
  - target: $["paths"]["/media/providers/refresh"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              await plexAPI.provider.refreshProviders();


            }

            run();
  - target: $["paths"]["/media/providers/{provider}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.provider.deleteMediaProvider({
                provider: "<value>",
              });


            }

            run();
  - target: $["paths"]["/media/subscriptions"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.subscriptions.getAllSubscriptions({
                includeGrabs: BoolInt.True,
                includeStorage: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/subscriptions"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.subscriptions.createSubscription({
                targetLibrarySectionID: 1,
                targetSectionLocationID: 3,
                mediaType: 2,
                hints: {},
                prefs: {},
                params: {},
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/subscriptions/process"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.subscriptions.processSubscriptions();

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/subscriptions/scheduled"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.subscriptions.getScheduledRecordings();

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/subscriptions/template"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.subscriptions.getTemplate({
                guid: "plex://episode/5fc70265c40548002d539d23",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/subscriptions/{subscriptionId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.subscriptions.deleteSubscription({
                subscriptionId: 974618,
              });


            }

            run();
  - target: $["paths"]["/media/subscriptions/{subscriptionId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.subscriptions.getSubscription({
                subscriptionId: 186713,
                includeGrabs: BoolInt.True,
                includeStorage: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/subscriptions/{subscriptionId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.subscriptions.editSubscriptionPreferences({
                subscriptionId: 673918,
                prefs: {},
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/media/subscriptions/{subscriptionId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.subscriptions.reorderSubscription({
                subscriptionId: 440634,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/music/:/transcode"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.transcoder.transcodeMusic({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/myplex/account"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.users.getMyPlexAccount();

              console.log(result);
            }

            run();
  - target: $["paths"]["/myplex/claim"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.claimServer({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/myplex/refreshReachability"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.general.refreshReachability();

              console.log(result);
            }

            run();
  - target: $["paths"]["/photo/:/transcode"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.transcoder.transcodeImage({
                url: "/library/metadata/265/thumb/1715112705",
                background: "#ff5522",
                upscale: BoolInt.True,
                minSize: BoolInt.True,
                rotate: BoolInt.True,
                blendColor: "#ff5522",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/ping"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI();

            async function run() {
              const result = await plexAPI.authentication.ping();

              console.log(result);
            }

            run();
  - target: $["paths"]["/pins"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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",
            });

            async function run() {
              const result = await plexAPI.authentication.createOAuthPin({
                clientIdentifier: "<YOUR_API_KEY_HERE>",
              }, {});

              console.log(result);
            }

            run();
  - target: $["paths"]["/pins.xml"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.authentication.createLegacyPin();

              console.log(result);
            }

            run();
  - target: $["paths"]["/pins/link"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.authentication.linkOAuthPin({
                authToken: "example",
                pin: "example",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/pins/{pinId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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",
            });

            async function run() {
              const result = await plexAPI.authentication.getOAuthPin({
                clientIdentifier: "<YOUR_API_KEY_HERE>",
              }, {
                pinId: 876892,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playQueues"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { CreatePlayQueueType } from "@parke.dev/plexjs/models/operations";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playQueue.createPlayQueue({
                mediaType: CreatePlayQueueType.Audio,
                shuffle: BoolInt.True,
                repeat: BoolInt.True,
                continuous: BoolInt.True,
                recursive: BoolInt.True,
                onDeck: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playQueues/1"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.timeline.getConversionQueue({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/playQueues/{playQueueId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playQueue.getPlayQueue({
                playQueueId: 210646,
                own: BoolInt.True,
                includeBefore: BoolInt.True,
                includeAfter: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playQueues/{playQueueId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playQueue.addToPlayQueue({
                playQueueId: 919248,
                next: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playQueues/{playQueueId}/items"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playQueue.clearPlayQueue({
                playQueueId: 86357,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playQueues/{playQueueId}/items/{playQueueItemId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playQueue.deletePlayQueueItem({
                playQueueId: 285738,
                playQueueItemId: 464354,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playQueues/{playQueueId}/items/{playQueueItemId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playQueue.movePlayQueueItem({
                playQueueId: 31341,
                playQueueItemId: 495865,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playQueues/{playQueueId}/reset"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playQueue.resetPlayQueue({
                playQueueId: 581891,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playQueues/{playQueueId}/shuffle"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playQueue.shuffle({
                playQueueId: 316150,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playQueues/{playQueueId}/unshuffle"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playQueue.unshuffle({
                playQueueId: 484388,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/audioStream"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerAudioStream({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/mute"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerMute({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/pause"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerPause({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/play"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerPlay({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/playMedia"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerPlayMedia({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/refreshPlayQueue"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerRefreshplayqueue({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/seek"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerSeek({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/setParameters"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerSetParameters({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/setRating"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerSetRating({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/setState"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerSetState({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/setStreams"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerSetStreams({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/setTextStream"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerSetTextStream({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/setViewOffset"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerSetViewOffset({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/skipBy"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerSkipBy({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/skipTo"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerSkipTo({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/stepBack"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerStepback({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/stepForward"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerStepforward({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/stop"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerStop({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/subtitleStream"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerSubtitleStream({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/unmute"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerUnmute({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/videoStream"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerVideoStream({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/playback/volume"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerVolume({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/resources"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.getClientResources({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/player/timeline/poll"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playback.playerPollTimeline({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/playlists"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playlists.deletePlaylistByRatingKey({
                ratingKey: 499749,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playlists"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playlist.listPlaylists({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/playlists"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.libraryPlaylists.createPlaylist({
                uri: "https://short-term-disconnection.name/",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playlists/upload"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.libraryPlaylists.uploadPlaylist({
                path: "/home/barkley/playlist.m3u",
                force: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/playlists/{playlistId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.libraryPlaylists.deletePlaylist({
                playlistId: 343293,
              });


            }

            run();
  - target: $["paths"]["/playlists/{playlistId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playlist.getPlaylist({
                playlistId: 841953,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playlists/{playlistId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.libraryPlaylists.updatePlaylist({
                playlistId: 157966,
              });


            }

            run();
  - target: $["paths"]["/playlists/{playlistId}/generators"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.libraryPlaylists.getPlaylistGenerators({
                playlistId: 162342,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playlists/{playlistId}/items"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.libraryPlaylists.clearPlaylistItems({
                playlistId: 552140,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playlists/{playlistId}/items"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.playlist.getPlaylistItems({
                playlistId: 118195,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playlists/{playlistId}/items"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.libraryPlaylists.addPlaylistItems({
                playlistId: 533723,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.libraryPlaylists.deletePlaylistItem({
                playlistId: 981646,
                generatorId: 194010,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.libraryPlaylists.getPlaylistGenerator({
                playlistId: 744880,
                generatorId: 322168,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { ModifyPlaylistGeneratorScope } from "@parke.dev/plexjs/models/operations";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.libraryPlaylists.modifyPlaylistGenerator({
                playlistId: 972007,
                generatorId: 208334,
                item: {
                  title: "Jack-Jack Attack",
                  type: 42,
                  location: {
                    uri: "library://82503060-0d68-4603-b594-8b071d54819e/item/%2Flibrary%2Fmetadata%2F146",
                  },
                  locationID: -1,
                  policy: {
                    scope: ModifyPlaylistGeneratorScope.All,
                  },
                  target: "",
                  targetTagID: 1,
                },
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}/items"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.libraryPlaylists.getPlaylistGeneratorItems({
                playlistId: 77230,
                generatorId: 979714,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}/{metadataId}/{action}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Action } from "@parke.dev/plexjs/models/operations";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.libraryPlaylists.refreshPlaylist({
                playlistId: 895314,
                generatorId: 629742,
                metadataId: 724422,
                action: Action.Disable,
              });


            }

            run();
  - target: $["paths"]["/playlists/{playlistId}/items/{playlistItemId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.libraryPlaylists.movePlaylistItem({
                playlistId: 940298,
                playlistItemId: 375626,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/resources"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { IncludeHttps, IncludeIPv6, IncludeRelay } from "@parke.dev/plexjs/models/operations";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: Accepts.ApplicationXml,
              clientIdentifier: "abc123",
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.plex.getServerResources({
                includeHttps: IncludeHttps.True,
                includeRelay: IncludeRelay.True,
                includeIPv6: IncludeIPv6.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/security/resources"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getSourceConnectionInformation({
                source: "server://client-identifier",
                refresh: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/security/token"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { CreateTransientTokenScope, CreateTransientTokenType } from "@parke.dev/plexjs/models/operations";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.createTransientToken({
                mediaType: CreateTransientTokenType.Delegation,
                scope: CreateTransientTokenScope.All,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/server"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.getUserServer({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/server/access_tokens"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.authentication.getServerAccessTokens({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/server/users/features"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.getServerUserFeatures({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/servers"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getLocalServers({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/servers/{machineId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.getServerDetails({
                machineId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/servers/{machineId}/shared_servers"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.shareServerLegacy({
                machineId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/services/browse"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.browseFilesystem({
                includeFiles: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/services/browse/{base64path}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.browseFilesystemPath({
                base64path: "<value>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/services/ultrablur/colors"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.ultraBlur.getColors({
                url: "/library/metadata/217745/art/1718931408",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/services/ultrablur/image"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.ultraBlur.getImage({
                topLeft: "3f280a",
                topRight: "6b4713",
                bottomRight: "0f2a43",
                bottomLeft: "1c425d",
                width: 1920,
                height: 1080,
                noise: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/shared_servers"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.shareServer({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/sharings/{userId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.removeShare({
                userId: 858924,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/sharings/{userId}"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.updateShare({
                userId: 139113,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/statistics/bandwidth"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getBandwidthStatistics({
                timespan: 4,
                lan: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/statistics/resources"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getResourceStatistics({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/status/sessions"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.status.listSessions();

              console.log(result);
            }

            run();
  - target: $["paths"]["/status/sessions/background"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.status.getBackgroundTasks();

              console.log(result);
            }

            run();
  - target: $["paths"]["/status/sessions/history/all"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.status.listPlaybackHistory({
                sort: [
                  "viewedAt:desc",
                  "accountID",
                ],
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/status/sessions/history/{historyId}"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.status.deleteHistory({
                historyId: 953579,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/status/sessions/history/{historyId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.status.getHistoryItem({
                historyId: 832213,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/status/sessions/terminate"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.status.terminateSession({
                sessionId: "cdefghijklmnopqrstuvwxyz",
                reason: "Stop Playing",
              });


            }

            run();
  - target: $["paths"]["/sync"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getSyncStatus({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/sync/items"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getSyncItems({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/sync/items/{syncId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getSyncItem({
                syncId: 761088,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/sync/queue"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getSyncQueue({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/sync/refreshContent"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.refreshSyncContent({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/sync/refreshSynclists"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.refreshSyncLists({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/sync/transcodeQueue"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getSyncTranscodeQueue({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/system/agents"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getMetadataAgents({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/system/agents/{agentId}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getMetadataAgentDetails({
                agentId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/system/settings"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getSystemSettings({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/system/updates"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.checkForSystemUpdates({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/transcode/sessions"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.transcoder.getTranscodeSessions();

              console.log(result);
            }

            run();
  - target: $["paths"]["/updater/apply"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.updater.applyUpdates({
                tonight: BoolInt.True,
                skip: BoolInt.True,
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/updater/check"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, BoolInt } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.updater.checkUpdates({
                download: BoolInt.True,
              });


            }

            run();
  - target: $["paths"]["/updater/status"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";

            const plexAPI = new PlexAPI({
              token: "<YOUR_API_KEY_HERE>",
            });

            async function run() {
              const result = await plexAPI.updater.getUpdatesStatus();

              console.log(result);
            }

            run();
  - target: $["paths"]["/user"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.authentication.getTokenDetails({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/user/view_state_sync"]["put"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.updateViewStateSync({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/user/{uuid}/settings/opt_outs"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.getUserOptOuts({
                uuid: "17dd8bb4-eb45-4878-97c7-017f7d9a2384",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/users"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.getUsers({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/users/account"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.getAccountXML({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/users/account.json"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.users.getAccountJSON({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/users/password"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.authentication.changePassword({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/users/signin"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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",
            });

            async function run() {
              const result = await plexAPI.authentication.postUsersSignInData({
                requestBody: {
                  login: "username@email.com",
                  password: "password123",
                  rememberMe: true,
                  verificationCode: "123456",
                },
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/users/signout"]["delete"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.authentication.signOut({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/webhooks"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.getWebhooks({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/webhooks"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.general.addWebhook({});

              console.log(result);
            }

            run();
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/decision"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { MakeDecisionLocation, MakeDecisionProtocol, MakeDecisionSubtitles } from "@parke.dev/plexjs/models/operations";
            import { Accepts, AdvancedSubtitles, BoolInt, TranscodeType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.transcoder.makeDecision({
                transcodeType: TranscodeType.Music,
                advancedSubtitles: AdvancedSubtitles.Burn,
                audioBoost: 50,
                audioChannelCount: 5,
                autoAdjustQuality: BoolInt.True,
                autoAdjustSubtitle: BoolInt.True,
                directPlay: BoolInt.True,
                directStream: BoolInt.True,
                directStreamAudio: BoolInt.True,
                disableResolutionRotation: BoolInt.True,
                hasMDE: BoolInt.True,
                location: MakeDecisionLocation.Wan,
                mediaBufferSize: 102400,
                mediaIndex: 0,
                musicBitrate: 5000,
                offset: 90.5,
                partIndex: 0,
                path: "/library/metadata/151671",
                peakBitrate: 12000,
                photoResolution: "1080x1080",
                protocol: MakeDecisionProtocol.Dash,
                secondsPerSegment: 5,
                subtitleSize: 50,
                subtitles: MakeDecisionSubtitles.Burn,
                videoResolution: "1080x1080",
                copyts: BoolInt.True,
                videoBitrate: 12000,
                videoQuality: 50,
                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",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/fallback"]["post"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts, TranscodeType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              await plexAPI.transcoder.triggerFallback({
                transcodeType: TranscodeType.Audio,
              });


            }

            run();
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/session/{sessionId}/{segmentId}.m4s"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.transcoder.getDASHSegment({
                transcodeType: "<value>",
                sessionId: "<id>",
                segmentId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/session/{sessionId}/{segmentId}.ts"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import { Accepts } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.transcoder.getHLSSegment({
                transcodeType: "<value>",
                sessionId: "<id>",
                segmentId: "<id>",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/start.{extension}"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import {
              Extension,
              StartTranscodeSessionLocation,
              StartTranscodeSessionProtocol,
              StartTranscodeSessionSubtitles,
            } from "@parke.dev/plexjs/models/operations";
            import { Accepts, AdvancedSubtitles, BoolInt, TranscodeType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.transcoder.startTranscodeSession({
                transcodeType: TranscodeType.Music,
                advancedSubtitles: AdvancedSubtitles.Burn,
                extension: Extension.Mpd,
                audioBoost: 50,
                audioChannelCount: 5,
                autoAdjustQuality: BoolInt.True,
                autoAdjustSubtitle: BoolInt.True,
                directPlay: BoolInt.True,
                directStream: BoolInt.True,
                directStreamAudio: BoolInt.True,
                disableResolutionRotation: BoolInt.True,
                hasMDE: BoolInt.True,
                location: StartTranscodeSessionLocation.Wan,
                mediaBufferSize: 102400,
                mediaIndex: 0,
                musicBitrate: 5000,
                offset: 90.5,
                partIndex: 0,
                path: "/library/metadata/151671",
                peakBitrate: 12000,
                photoResolution: "1080x1080",
                protocol: StartTranscodeSessionProtocol.Dash,
                secondsPerSegment: 5,
                subtitleSize: 50,
                subtitles: StartTranscodeSessionSubtitles.Burn,
                videoResolution: "1080x1080",
                copyts: BoolInt.True,
                videoBitrate: 12000,
                videoQuality: 50,
                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",
              });

              console.log(result);
            }

            run();
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/subtitles"]["get"]
    update:
      x-codeSamples:
        - lang: typescript
          label: PlexJS
          source: |-
            import { PlexAPI } from "@parke.dev/plexjs";
            import {
              TranscodeSubtitlesLocation,
              TranscodeSubtitlesProtocol,
              TranscodeSubtitlesSubtitles,
            } from "@parke.dev/plexjs/models/operations";
            import { Accepts, AdvancedSubtitles, BoolInt, TranscodeType } from "@parke.dev/plexjs/models/shared";

            const plexAPI = new PlexAPI({
              accepts: 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>",
            });

            async function run() {
              const result = await plexAPI.transcoder.transcodeSubtitles({
                transcodeType: TranscodeType.Audio,
                advancedSubtitles: AdvancedSubtitles.Burn,
                audioBoost: 50,
                audioChannelCount: 5,
                autoAdjustQuality: BoolInt.True,
                autoAdjustSubtitle: BoolInt.True,
                directPlay: BoolInt.True,
                directStream: BoolInt.True,
                directStreamAudio: BoolInt.True,
                disableResolutionRotation: BoolInt.True,
                hasMDE: BoolInt.True,
                location: TranscodeSubtitlesLocation.Wan,
                mediaBufferSize: 102400,
                mediaIndex: 0,
                musicBitrate: 5000,
                offset: 90.5,
                partIndex: 0,
                path: "/library/metadata/151671",
                peakBitrate: 12000,
                photoResolution: "1080x1080",
                protocol: TranscodeSubtitlesProtocol.Dash,
                secondsPerSegment: 5,
                subtitleSize: 50,
                subtitles: TranscodeSubtitlesSubtitles.Burn,
                videoResolution: "1080x1080",
                copyts: BoolInt.True,
                videoBitrate: 12000,
                videoQuality: 50,
                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",
              });

              console.log(result);
            }

            run();