overlay: 1.0.0
info:
  title: CodeSamples overlay for go target
  version: 0.0.0
actions:
  - target: $["paths"]["/"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Server.GetServerCapabilities(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/:/prefs"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Server.GetServerPreferences(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/:/progress"]["post"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Media.UpdatePlayProgress(ctx, "<key>", 90000, "played")
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/:/scrobble"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Media.MarkPlayed(ctx, 59398)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/:/timeline"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Video.GetTimeline(ctx, operations.GetTimelineRequest{
                    RatingKey: 23409,
                    Key: "/library/metadata/23409",
                    State: operations.StatePlaying,
                    HasMDE: 1,
                    Time: 2000,
                    Duration: 10000,
                    Context: "home:hub.continueWatching",
                    PlayQueueItemID: 1,
                    PlayBackTime: 2000,
                    Row: 1,
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/:/unscrobble"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Media.MarkUnplayed(ctx, 59398)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/activities"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Activities.GetServerActivities(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/activities/{activityUUID}"]["delete"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Activities.CancelServerActivities(ctx, "25b71ed5-0f9d-461c-baa7-d404e9e10d3e")
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/butler"]["delete"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Butler.StopAllTasks(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/butler"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Butler.GetButlerTasks(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/butler"]["post"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Butler.StartAllTasks(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/butler/{taskName}"]["delete"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Butler.StopTask(ctx, operations.PathParamTaskNameCleanOldCacheFiles)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/butler/{taskName}"]["post"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Butler.StartTask(ctx, operations.TaskNameRefreshPeriodicMetadata)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/clients"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Server.GetAvailableClients(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/companions"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Plex.GetCompanionsData(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.ResponseBodies != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/devices"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Server.GetDevices(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/friends"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Plex.GetUserFriends(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Friends != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/geoip"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New()

                res, err := s.Plex.GetGeoData(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.GeoData != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/home"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Plex.GetHomeData(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/hubs"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Hubs.GetGlobalHubs(ctx, nil, nil)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/hubs/home/recentlyAdded"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Hubs.GetRecentlyAdded(ctx, operations.GetRecentlyAddedRequest{
                    ContentDirectoryID: 39486,
                    SectionID: plexgo.Pointer[int64](2),
                    Type: operations.TypeTvShow,
                    IncludeMeta: operations.IncludeMetaEnable.ToPointer(),
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/hubs/search"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Search.PerformSearch(ctx, "arnold", nil, plexgo.Pointer[float64](5))
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/hubs/search/voice"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Search.PerformVoiceSearch(ctx, "dead+poop", nil, plexgo.Pointer[float64](5))
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/hubs/sections/{sectionId}"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Hubs.GetLibraryHubs(ctx, 492.74, nil, nil)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/identity"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New()

                res, err := s.Server.GetServerIdentity(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/all/top"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetTopWatchedContent(ctx, operations.GetTopWatchedContentQueryParamTypeTvShow, operations.GetTopWatchedContentQueryParamIncludeGuidsEnable.ToPointer())
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/hashes"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetFileHash(ctx, "file://C:\\Image.png&type=13", nil)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/metadata/{ratingKey}"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetMediaMetaData(ctx, operations.GetMediaMetaDataRequest{
                    RatingKey: "21119,21617",
                    IncludeConcerts: plexgo.Pointer(true),
                    IncludeExtras: plexgo.Pointer(true),
                    IncludeOnDeck: plexgo.Pointer(true),
                    IncludePopularLeaves: plexgo.Pointer(true),
                    IncludePreferences: plexgo.Pointer(true),
                    IncludeReviews: plexgo.Pointer(true),
                    IncludeChapters: plexgo.Pointer(true),
                    IncludeStations: plexgo.Pointer(true),
                    IncludeExternalMedia: plexgo.Pointer(true),
                    AsyncAugmentMetadata: plexgo.Pointer(true),
                    AsyncCheckFiles: plexgo.Pointer(true),
                    AsyncRefreshAnalysis: plexgo.Pointer(true),
                    AsyncRefreshLocalMediaAgent: plexgo.Pointer(true),
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/metadata/{ratingKey}/arts"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetMediaArts(ctx, 16099)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/metadata/{ratingKey}/arts"]["post"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.PostMediaArts(ctx, 2268, plexgo.Pointer("https://api.mediux.pro/assets/fcfdc487-dd07-4993-a0c1-0a3015362e5b"), nil)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/metadata/{ratingKey}/banner"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Media.GetBannerImage(ctx, operations.GetBannerImageRequest{
                    RatingKey: 9518,
                    Width: 396,
                    Height: 396,
                    MinSize: 1,
                    Upscale: 1,
                    XPlexToken: "CV5xoxjTpFKUzBTShsaf",
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.ResponseStream != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/metadata/{ratingKey}/children"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetMetadataChildren(ctx, 2403.67, plexgo.Pointer("Stream"))
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/metadata/{ratingKey}/posters"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetMediaPosters(ctx, 16099)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/metadata/{ratingKey}/posters"]["post"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.PostMediaPoster(ctx, 2268, plexgo.Pointer("https://api.mediux.pro/assets/fcfdc487-dd07-4993-a0c1-0a3015362e5b"), nil)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/metadata/{ratingKey}/thumb"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Media.GetThumbImage(ctx, operations.GetThumbImageRequest{
                    RatingKey: 9518,
                    Width: 396,
                    Height: 396,
                    MinSize: 1,
                    Upscale: 1,
                    XPlexToken: "CV5xoxjTpFKUzBTShsaf",
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.ResponseStream != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/recentlyAdded"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetRecentlyAddedLibrary(ctx, operations.GetRecentlyAddedLibraryRequest{
                    ContentDirectoryID: plexgo.Pointer[int64](2),
                    PinnedContentDirectoryID: []int64{
                        3,
                        5,
                        7,
                        13,
                        12,
                        1,
                        6,
                        14,
                        2,
                        10,
                        16,
                        17,
                    },
                    SectionID: plexgo.Pointer[int64](2),
                    Type: operations.QueryParamTypeTvShow,
                    IncludeMeta: operations.QueryParamIncludeMetaEnable.ToPointer(),
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/search"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetSearchAllLibraries(ctx, operations.GetSearchAllLibrariesRequest{
                    Query: "<value>",
                    ClientID: "3381b62b-9ab7-4e37-827b-203e9809eb58",
                    SearchTypes: []operations.SearchTypes{
                        operations.SearchTypesPeople,
                    },
                    IncludeCollections: operations.GetSearchAllLibrariesQueryParamIncludeCollectionsEnable.ToPointer(),
                    IncludeExternalMedia: operations.GetSearchAllLibrariesQueryParamIncludeExternalMediaEnable.ToPointer(),
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/sections"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetAllLibraries(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/sections/watchlist/{filter}"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Watchlist.GetWatchList(ctx, operations.GetWatchListRequest{
                    Filter: operations.FilterReleased,
                    XPlexToken: "CV5xoxjTpFKUzBTShsaf",
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/sections/{sectionKey}"]["delete"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.DeleteLibrary(ctx, 9518)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/sections/{sectionKey}"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetLibraryDetails(ctx, 9518, operations.IncludeDetailsZero.ToPointer())
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/sections/{sectionKey}/actor"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetActorsLibrary(ctx, 9518, operations.GetActorsLibraryQueryParamTypeTvShow)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/sections/{sectionKey}/all"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetLibrarySectionsAll(ctx, operations.GetLibrarySectionsAllRequest{
                    SectionKey: 9518,
                    Type: operations.GetLibrarySectionsAllQueryParamTypeTvShow,
                    IncludeMeta: operations.GetLibrarySectionsAllQueryParamIncludeMetaEnable.ToPointer(),
                    IncludeGuids: operations.QueryParamIncludeGuidsEnable.ToPointer(),
                    IncludeAdvanced: operations.IncludeAdvancedEnable.ToPointer(),
                    IncludeCollections: operations.QueryParamIncludeCollectionsEnable.ToPointer(),
                    IncludeExternalMedia: operations.QueryParamIncludeExternalMediaEnable.ToPointer(),
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/sections/{sectionKey}/country"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetCountriesLibrary(ctx, 9518, operations.GetCountriesLibraryQueryParamTypeTvShow)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/sections/{sectionKey}/genre"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetGenresLibrary(ctx, 9518, operations.GetGenresLibraryQueryParamTypeTvShow)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/sections/{sectionKey}/refresh"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetRefreshLibraryMetadata(ctx, 9518, operations.ForceZero.ToPointer())
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/sections/{sectionKey}/search"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetSearchLibrary(ctx, 9518, operations.GetSearchLibraryQueryParamTypeTvShow)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/library/sections/{sectionKey}/{tag}"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Library.GetLibraryItems(ctx, operations.GetLibraryItemsRequest{
                    Tag: operations.TagNewest,
                    IncludeGuids: operations.IncludeGuidsEnable.ToPointer(),
                    Type: operations.GetLibraryItemsQueryParamTypeTvShow,
                    SectionKey: 9518,
                    IncludeMeta: operations.GetLibraryItemsQueryParamIncludeMetaEnable.ToPointer(),
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/log"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Log.LogLine(ctx, operations.LevelThree, "Test log message", "Postman")
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/log"]["post"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Log.LogMultiLine(ctx, "level=4&message=Test%20message%201&source=postman\n" +
                "level=3&message=Test%20message%202&source=postman\n" +
                "level=1&message=Test%20message%203&source=postman")
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/log/networked"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Log.EnablePaperTrail(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/media/providers"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Server.GetMediaProviders(ctx, "CV5xoxjTpFKUzBTShsaf")
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/myplex/account"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Server.GetMyPlexAccount(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/photo/:/transcode"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Server.GetResizedPhoto(ctx, operations.GetResizedPhotoRequest{
                    Width: 110,
                    Height: 165,
                    Blur: 0,
                    MinSize: operations.MinSizeZero,
                    Upscale: operations.UpscaleZero,
                    URL: "/library/metadata/49564/thumb/1654258204",
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/pins"]["post"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New()

                res, err := s.Plex.GetPin(ctx, operations.GetPinRequest{
                    ClientID: "3381b62b-9ab7-4e37-827b-203e9809eb58",
                    ClientName: plexgo.Pointer("Plex for Roku"),
                    DeviceNickname: plexgo.Pointer("Roku 3"),
                    ClientVersion: plexgo.Pointer("2.4.1"),
                    Platform: plexgo.Pointer("Roku"),
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.AuthPinContainer != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/pins/{pinID}"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New()

                res, err := s.Plex.GetTokenByPinID(ctx, operations.GetTokenByPinIDRequest{
                    PinID: 232248,
                    ClientID: "3381b62b-9ab7-4e37-827b-203e9809eb58",
                    ClientName: plexgo.Pointer("Plex for Roku"),
                    DeviceNickname: plexgo.Pointer("Roku 3"),
                    ClientVersion: plexgo.Pointer("2.4.1"),
                    Platform: plexgo.Pointer("Roku"),
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.AuthPinContainer != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/playlists"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Playlists.GetPlaylists(ctx, nil, nil)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/playlists"]["post"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Playlists.CreatePlaylist(ctx, operations.CreatePlaylistRequest{
                    Title: "<value>",
                    Type: operations.CreatePlaylistQueryParamTypeAudio,
                    Smart: operations.SmartOne,
                    URI: "https://short-term-disconnection.name/",
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/playlists/upload"]["post"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Playlists.UploadPlaylist(ctx, "/home/barkley/playlist.m3u", operations.QueryParamForceOne, 1)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/playlists/{playlistID}"]["delete"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Playlists.DeletePlaylist(ctx, 3432.93)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/playlists/{playlistID}"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Playlists.GetPlaylist(ctx, 8419.53)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/playlists/{playlistID}"]["put"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Playlists.UpdatePlaylist(ctx, 1579.66, nil, nil)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/playlists/{playlistID}/items"]["delete"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Playlists.ClearPlaylistContents(ctx, 4137.37)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/playlists/{playlistID}/items"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Playlists.GetPlaylistContents(ctx, 5535.42, operations.GetPlaylistContentsQueryParamTypeTvShow)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/playlists/{playlistID}/items"]["put"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Playlists.AddPlaylistContents(ctx, 7013.44, "server://12345/com.plexapp.plugins.library/library/metadata/1", plexgo.Pointer[float64](123))
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/resources"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Plex.GetServerResources(ctx, "3381b62b-9ab7-4e37-827b-203e9809eb58", operations.IncludeHTTPSEnable.ToPointer(), operations.IncludeRelayEnable.ToPointer(), operations.IncludeIPv6Enable.ToPointer())
                if err != nil {
                    log.Fatal(err)
                }
                if res.PlexDevices != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/search"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Search.GetSearchResults(ctx, "110")
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/security/resources"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Authentication.GetSourceConnectionInformation(ctx, "server://client-identifier")
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/security/token"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Authentication.GetTransientToken(ctx, operations.GetTransientTokenQueryParamTypeDelegation, operations.ScopeAll)
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/servers"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Server.GetServerList(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/statistics/bandwidth"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Statistics.GetBandwidthStatistics(ctx, plexgo.Pointer[int64](4))
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/statistics/media"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Statistics.GetStatistics(ctx, plexgo.Pointer[int64](4))
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/statistics/resources"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Statistics.GetResourcesStatistics(ctx, plexgo.Pointer[int64](4))
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/status/sessions"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Sessions.GetSessions(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/status/sessions/history/all"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Sessions.GetSessionHistory(ctx, plexgo.Pointer("viewedAt:desc"), plexgo.Pointer[int64](1), &operations.QueryParamFilter{}, plexgo.Pointer[int64](12))
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/transcode/sessions"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Sessions.GetTranscodeSessions(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/transcode/sessions/{sessionKey}"]["delete"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Sessions.StopTranscodeSession(ctx, "zz7llzqlx8w9vnrsbnwhbmep")
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/updater/apply"]["put"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Updater.ApplyUpdates(ctx, operations.TonightOne.ToPointer(), operations.SkipOne.ToPointer())
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/updater/check"]["put"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Updater.CheckForUpdates(ctx, operations.DownloadOne.ToPointer())
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/updater/status"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Updater.GetUpdateStatus(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.Object != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/user"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Authentication.GetTokenDetails(ctx)
                if err != nil {
                    log.Fatal(err)
                }
                if res.UserPlexAccount != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/users"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New()

                res, err := s.Users.GetUsers(ctx, operations.GetUsersRequest{
                    ClientID: "3381b62b-9ab7-4e37-827b-203e9809eb58",
                    ClientName: plexgo.Pointer("Plex for Roku"),
                    DeviceNickname: plexgo.Pointer("Roku 3"),
                    DeviceName: plexgo.Pointer("Chrome"),
                    DeviceScreenResolution: plexgo.Pointer("1487x1165,2560x1440"),
                    ClientVersion: plexgo.Pointer("2.4.1"),
                    Platform: plexgo.Pointer("Roku"),
                    ClientFeatures: plexgo.Pointer("external-media,indirect-media,hub-style-list"),
                    Model: plexgo.Pointer("4200X"),
                    XPlexSessionID: plexgo.Pointer("97e136ef-4ddd-4ff3-89a7-a5820c96c2ca"),
                    XPlexLanguage: plexgo.Pointer("en"),
                    PlatformVersion: plexgo.Pointer("4.3 build 1057"),
                    XPlexToken: "CV5xoxjTpFKUzBTShsaf",
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.Body != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/users/signin"]["post"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New()

                res, err := s.Authentication.PostUsersSignInData(ctx, operations.PostUsersSignInDataRequest{
                    ClientID: "3381b62b-9ab7-4e37-827b-203e9809eb58",
                    ClientName: plexgo.Pointer("Plex for Roku"),
                    DeviceNickname: plexgo.Pointer("Roku 3"),
                    ClientVersion: plexgo.Pointer("2.4.1"),
                    Platform: plexgo.Pointer("Roku"),
                    RequestBody: &operations.PostUsersSignInDataRequestBody{
                        Login: "username@email.com",
                        Password: "password123",
                        VerificationCode: plexgo.Pointer("123456"),
                    },
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res.UserPlexAccount != nil {
                    // handle response
                }
            }
  - target: $["paths"]["/video/:/transcode/universal/start.mpd"]["get"]
    update:
      x-codeSamples:
        - lang: go
          label: PlexGO
          source: |-
            package main

            import(
            	"context"
            	"github.com/LukeHagar/plexgo"
            	"github.com/LukeHagar/plexgo/models/operations"
            	"log"
            )

            func main() {
                ctx := context.Background()

                s := plexgo.New(
                    plexgo.WithSecurity("<YOUR_API_KEY_HERE>"),
                )

                res, err := s.Video.StartUniversalTranscode(ctx, operations.StartUniversalTranscodeRequest{
                    HasMDE: 1,
                    Path: "/library/metadata/23409",
                    MediaIndex: 0,
                    PartIndex: 0,
                    Protocol: "hls",
                    FastSeek: plexgo.Pointer[float64](0),
                    DirectPlay: plexgo.Pointer[float64](0),
                    DirectStream: plexgo.Pointer[float64](0),
                    SubtitleSize: plexgo.Pointer[float64](100),
                    Subtites: plexgo.Pointer("burn"),
                    AudioBoost: plexgo.Pointer[float64](100),
                    Location: plexgo.Pointer("lan"),
                    MediaBufferSize: plexgo.Pointer[float64](102400),
                    Session: plexgo.Pointer("zvcage8b7rkioqcm8f4uns4c"),
                    AddDebugOverlay: plexgo.Pointer[float64](0),
                    AutoAdjustQuality: plexgo.Pointer[float64](0),
                })
                if err != nil {
                    log.Fatal(err)
                }
                if res != nil {
                    // handle response
                }
            }