ci: regenerated with OpenAPI Doc , Speakeasy CLI 1.396.6

2025-12-07 04:20:49 +00:00 · 2024-09-13 00:25:35 +00:00
parent f83d7949e1
commit 5585a18ab9
652 changed files with 34020 additions and 4554 deletions
--- a/src/main/java/dev/plexapi/sdk/Playlists.java
+++ b/src/main/java/dev/plexapi/sdk/Playlists.java
@@ -5,11 +5,25 @@
 package dev.plexapi.sdk;

 import com.fasterxml.jackson.core.type.TypeReference;
-import dev.plexapi.sdk.models.errors.ClearPlaylistContentsResponseBody;
-import dev.plexapi.sdk.models.errors.DeletePlaylistResponseBody;
+import dev.plexapi.sdk.models.errors.AddPlaylistContentsBadRequest;
+import dev.plexapi.sdk.models.errors.AddPlaylistContentsUnauthorized;
+import dev.plexapi.sdk.models.errors.ClearPlaylistContentsBadRequest;
+import dev.plexapi.sdk.models.errors.ClearPlaylistContentsUnauthorized;
+import dev.plexapi.sdk.models.errors.CreatePlaylistBadRequest;
+import dev.plexapi.sdk.models.errors.CreatePlaylistUnauthorized;
+import dev.plexapi.sdk.models.errors.DeletePlaylistBadRequest;
+import dev.plexapi.sdk.models.errors.DeletePlaylistUnauthorized;
+import dev.plexapi.sdk.models.errors.GetPlaylistBadRequest;
+import dev.plexapi.sdk.models.errors.GetPlaylistContentsBadRequest;
+import dev.plexapi.sdk.models.errors.GetPlaylistContentsUnauthorized;
+import dev.plexapi.sdk.models.errors.GetPlaylistUnauthorized;
+import dev.plexapi.sdk.models.errors.GetPlaylistsBadRequest;
+import dev.plexapi.sdk.models.errors.GetPlaylistsUnauthorized;
 import dev.plexapi.sdk.models.errors.SDKError;
-import dev.plexapi.sdk.models.errors.UpdatePlaylistResponseBody;
-import dev.plexapi.sdk.models.errors.UploadPlaylistResponseBody;
+import dev.plexapi.sdk.models.errors.UpdatePlaylistBadRequest;
+import dev.plexapi.sdk.models.errors.UpdatePlaylistUnauthorized;
+import dev.plexapi.sdk.models.errors.UploadPlaylistBadRequest;
+import dev.plexapi.sdk.models.errors.UploadPlaylistUnauthorized;
 import dev.plexapi.sdk.models.operations.AddPlaylistContentsRequest;
 import dev.plexapi.sdk.models.operations.AddPlaylistContentsRequestBuilder;
 import dev.plexapi.sdk.models.operations.AddPlaylistContentsResponse;
@@ -198,19 +212,11 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400", "4XX", "5XX")) {
-            // no content 
-            throw new SDKError(
-                    _httpRes, 
-                    _httpRes.statusCode(), 
-                    "API error occurred", 
-                    Utils.extractByteArrayFromBody(_httpRes));
-        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400")) {
            if (Utils.contentTypeMatches(_contentType, "application/json")) {
-                dev.plexapi.sdk.models.errors.CreatePlaylistResponseBody _out = Utils.mapper().readValue(
+                CreatePlaylistBadRequest _out = Utils.mapper().readValue(
                    Utils.toUtf8AndClose(_httpRes.body()),
-                    new TypeReference<dev.plexapi.sdk.models.errors.CreatePlaylistResponseBody>() {});
+                    new TypeReference<CreatePlaylistBadRequest>() {});
                    _out.withRawResponse(Optional.ofNullable(_httpRes));
                
                throw _out;
@@ -222,6 +228,30 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+            if (Utils.contentTypeMatches(_contentType, "application/json")) {
+                CreatePlaylistUnauthorized _out = Utils.mapper().readValue(
+                    Utils.toUtf8AndClose(_httpRes.body()),
+                    new TypeReference<CreatePlaylistUnauthorized>() {});
+                    _out.withRawResponse(Optional.ofNullable(_httpRes));
+                
+                throw _out;
+            } else {
+                throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "Unexpected content-type received: " + _contentType, 
+                    Utils.extractByteArrayFromBody(_httpRes));
+            }
+        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "4XX", "5XX")) {
+            // no content 
+            throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "API error occurred", 
+                    Utils.extractByteArrayFromBody(_httpRes));
+        }
        throw new SDKError(
            _httpRes, 
            _httpRes.statusCode(), 
@@ -355,19 +385,11 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400", "4XX", "5XX")) {
-            // no content 
-            throw new SDKError(
-                    _httpRes, 
-                    _httpRes.statusCode(), 
-                    "API error occurred", 
-                    Utils.extractByteArrayFromBody(_httpRes));
-        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400")) {
            if (Utils.contentTypeMatches(_contentType, "application/json")) {
-                dev.plexapi.sdk.models.errors.GetPlaylistsResponseBody _out = Utils.mapper().readValue(
+                GetPlaylistsBadRequest _out = Utils.mapper().readValue(
                    Utils.toUtf8AndClose(_httpRes.body()),
-                    new TypeReference<dev.plexapi.sdk.models.errors.GetPlaylistsResponseBody>() {});
+                    new TypeReference<GetPlaylistsBadRequest>() {});
                    _out.withRawResponse(Optional.ofNullable(_httpRes));
                
                throw _out;
@@ -379,6 +401,30 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+            if (Utils.contentTypeMatches(_contentType, "application/json")) {
+                GetPlaylistsUnauthorized _out = Utils.mapper().readValue(
+                    Utils.toUtf8AndClose(_httpRes.body()),
+                    new TypeReference<GetPlaylistsUnauthorized>() {});
+                    _out.withRawResponse(Optional.ofNullable(_httpRes));
+                
+                throw _out;
+            } else {
+                throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "Unexpected content-type received: " + _contentType, 
+                    Utils.extractByteArrayFromBody(_httpRes));
+            }
+        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "4XX", "5XX")) {
+            // no content 
+            throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "API error occurred", 
+                    Utils.extractByteArrayFromBody(_httpRes));
+        }
        throw new SDKError(
            _httpRes, 
            _httpRes.statusCode(), 
@@ -500,19 +546,11 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400", "4XX", "5XX")) {
-            // no content 
-            throw new SDKError(
-                    _httpRes, 
-                    _httpRes.statusCode(), 
-                    "API error occurred", 
-                    Utils.extractByteArrayFromBody(_httpRes));
-        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400")) {
            if (Utils.contentTypeMatches(_contentType, "application/json")) {
-                dev.plexapi.sdk.models.errors.GetPlaylistResponseBody _out = Utils.mapper().readValue(
+                GetPlaylistBadRequest _out = Utils.mapper().readValue(
                    Utils.toUtf8AndClose(_httpRes.body()),
-                    new TypeReference<dev.plexapi.sdk.models.errors.GetPlaylistResponseBody>() {});
+                    new TypeReference<GetPlaylistBadRequest>() {});
                    _out.withRawResponse(Optional.ofNullable(_httpRes));
                
                throw _out;
@@ -524,6 +562,30 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+            if (Utils.contentTypeMatches(_contentType, "application/json")) {
+                GetPlaylistUnauthorized _out = Utils.mapper().readValue(
+                    Utils.toUtf8AndClose(_httpRes.body()),
+                    new TypeReference<GetPlaylistUnauthorized>() {});
+                    _out.withRawResponse(Optional.ofNullable(_httpRes));
+                
+                throw _out;
+            } else {
+                throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "Unexpected content-type received: " + _contentType, 
+                    Utils.extractByteArrayFromBody(_httpRes));
+            }
+        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "4XX", "5XX")) {
+            // no content 
+            throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "API error occurred", 
+                    Utils.extractByteArrayFromBody(_httpRes));
+        }
        throw new SDKError(
            _httpRes, 
            _httpRes.statusCode(), 
@@ -632,19 +694,11 @@ public class Playlists implements
            // no content 
            return _res;
        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400", "4XX", "5XX")) {
-            // no content 
-            throw new SDKError(
-                    _httpRes, 
-                    _httpRes.statusCode(), 
-                    "API error occurred", 
-                    Utils.extractByteArrayFromBody(_httpRes));
-        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400")) {
            if (Utils.contentTypeMatches(_contentType, "application/json")) {
-                DeletePlaylistResponseBody _out = Utils.mapper().readValue(
+                DeletePlaylistBadRequest _out = Utils.mapper().readValue(
                    Utils.toUtf8AndClose(_httpRes.body()),
-                    new TypeReference<DeletePlaylistResponseBody>() {});
+                    new TypeReference<DeletePlaylistBadRequest>() {});
                    _out.withRawResponse(Optional.ofNullable(_httpRes));
                
                throw _out;
@@ -656,6 +710,30 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+            if (Utils.contentTypeMatches(_contentType, "application/json")) {
+                DeletePlaylistUnauthorized _out = Utils.mapper().readValue(
+                    Utils.toUtf8AndClose(_httpRes.body()),
+                    new TypeReference<DeletePlaylistUnauthorized>() {});
+                    _out.withRawResponse(Optional.ofNullable(_httpRes));
+                
+                throw _out;
+            } else {
+                throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "Unexpected content-type received: " + _contentType, 
+                    Utils.extractByteArrayFromBody(_httpRes));
+            }
+        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "4XX", "5XX")) {
+            // no content 
+            throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "API error occurred", 
+                    Utils.extractByteArrayFromBody(_httpRes));
+        }
        throw new SDKError(
            _httpRes, 
            _httpRes.statusCode(), 
@@ -788,19 +866,11 @@ public class Playlists implements
            // no content 
            return _res;
        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400", "4XX", "5XX")) {
-            // no content 
-            throw new SDKError(
-                    _httpRes, 
-                    _httpRes.statusCode(), 
-                    "API error occurred", 
-                    Utils.extractByteArrayFromBody(_httpRes));
-        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400")) {
            if (Utils.contentTypeMatches(_contentType, "application/json")) {
-                UpdatePlaylistResponseBody _out = Utils.mapper().readValue(
+                UpdatePlaylistBadRequest _out = Utils.mapper().readValue(
                    Utils.toUtf8AndClose(_httpRes.body()),
-                    new TypeReference<UpdatePlaylistResponseBody>() {});
+                    new TypeReference<UpdatePlaylistBadRequest>() {});
                    _out.withRawResponse(Optional.ofNullable(_httpRes));
                
                throw _out;
@@ -812,6 +882,30 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+            if (Utils.contentTypeMatches(_contentType, "application/json")) {
+                UpdatePlaylistUnauthorized _out = Utils.mapper().readValue(
+                    Utils.toUtf8AndClose(_httpRes.body()),
+                    new TypeReference<UpdatePlaylistUnauthorized>() {});
+                    _out.withRawResponse(Optional.ofNullable(_httpRes));
+                
+                throw _out;
+            } else {
+                throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "Unexpected content-type received: " + _contentType, 
+                    Utils.extractByteArrayFromBody(_httpRes));
+            }
+        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "4XX", "5XX")) {
+            // no content 
+            throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "API error occurred", 
+                    Utils.extractByteArrayFromBody(_httpRes));
+        }
        throw new SDKError(
            _httpRes, 
            _httpRes.statusCode(), 
@@ -951,19 +1045,11 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400", "4XX", "5XX")) {
-            // no content 
-            throw new SDKError(
-                    _httpRes, 
-                    _httpRes.statusCode(), 
-                    "API error occurred", 
-                    Utils.extractByteArrayFromBody(_httpRes));
-        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400")) {
            if (Utils.contentTypeMatches(_contentType, "application/json")) {
-                dev.plexapi.sdk.models.errors.GetPlaylistContentsResponseBody _out = Utils.mapper().readValue(
+                GetPlaylistContentsBadRequest _out = Utils.mapper().readValue(
                    Utils.toUtf8AndClose(_httpRes.body()),
-                    new TypeReference<dev.plexapi.sdk.models.errors.GetPlaylistContentsResponseBody>() {});
+                    new TypeReference<GetPlaylistContentsBadRequest>() {});
                    _out.withRawResponse(Optional.ofNullable(_httpRes));
                
                throw _out;
@@ -975,6 +1061,30 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+            if (Utils.contentTypeMatches(_contentType, "application/json")) {
+                GetPlaylistContentsUnauthorized _out = Utils.mapper().readValue(
+                    Utils.toUtf8AndClose(_httpRes.body()),
+                    new TypeReference<GetPlaylistContentsUnauthorized>() {});
+                    _out.withRawResponse(Optional.ofNullable(_httpRes));
+                
+                throw _out;
+            } else {
+                throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "Unexpected content-type received: " + _contentType, 
+                    Utils.extractByteArrayFromBody(_httpRes));
+            }
+        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "4XX", "5XX")) {
+            // no content 
+            throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "API error occurred", 
+                    Utils.extractByteArrayFromBody(_httpRes));
+        }
        throw new SDKError(
            _httpRes, 
            _httpRes.statusCode(), 
@@ -1083,19 +1193,11 @@ public class Playlists implements
            // no content 
            return _res;
        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400", "4XX", "5XX")) {
-            // no content 
-            throw new SDKError(
-                    _httpRes, 
-                    _httpRes.statusCode(), 
-                    "API error occurred", 
-                    Utils.extractByteArrayFromBody(_httpRes));
-        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400")) {
            if (Utils.contentTypeMatches(_contentType, "application/json")) {
-                ClearPlaylistContentsResponseBody _out = Utils.mapper().readValue(
+                ClearPlaylistContentsBadRequest _out = Utils.mapper().readValue(
                    Utils.toUtf8AndClose(_httpRes.body()),
-                    new TypeReference<ClearPlaylistContentsResponseBody>() {});
+                    new TypeReference<ClearPlaylistContentsBadRequest>() {});
                    _out.withRawResponse(Optional.ofNullable(_httpRes));
                
                throw _out;
@@ -1107,6 +1209,30 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+            if (Utils.contentTypeMatches(_contentType, "application/json")) {
+                ClearPlaylistContentsUnauthorized _out = Utils.mapper().readValue(
+                    Utils.toUtf8AndClose(_httpRes.body()),
+                    new TypeReference<ClearPlaylistContentsUnauthorized>() {});
+                    _out.withRawResponse(Optional.ofNullable(_httpRes));
+                
+                throw _out;
+            } else {
+                throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "Unexpected content-type received: " + _contentType, 
+                    Utils.extractByteArrayFromBody(_httpRes));
+            }
+        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "4XX", "5XX")) {
+            // no content 
+            throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "API error occurred", 
+                    Utils.extractByteArrayFromBody(_httpRes));
+        }
        throw new SDKError(
            _httpRes, 
            _httpRes.statusCode(), 
@@ -1255,19 +1381,11 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400", "4XX", "5XX")) {
-            // no content 
-            throw new SDKError(
-                    _httpRes, 
-                    _httpRes.statusCode(), 
-                    "API error occurred", 
-                    Utils.extractByteArrayFromBody(_httpRes));
-        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400")) {
            if (Utils.contentTypeMatches(_contentType, "application/json")) {
-                dev.plexapi.sdk.models.errors.AddPlaylistContentsResponseBody _out = Utils.mapper().readValue(
+                AddPlaylistContentsBadRequest _out = Utils.mapper().readValue(
                    Utils.toUtf8AndClose(_httpRes.body()),
-                    new TypeReference<dev.plexapi.sdk.models.errors.AddPlaylistContentsResponseBody>() {});
+                    new TypeReference<AddPlaylistContentsBadRequest>() {});
                    _out.withRawResponse(Optional.ofNullable(_httpRes));
                
                throw _out;
@@ -1279,6 +1397,30 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+            if (Utils.contentTypeMatches(_contentType, "application/json")) {
+                AddPlaylistContentsUnauthorized _out = Utils.mapper().readValue(
+                    Utils.toUtf8AndClose(_httpRes.body()),
+                    new TypeReference<AddPlaylistContentsUnauthorized>() {});
+                    _out.withRawResponse(Optional.ofNullable(_httpRes));
+                
+                throw _out;
+            } else {
+                throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "Unexpected content-type received: " + _contentType, 
+                    Utils.extractByteArrayFromBody(_httpRes));
+            }
+        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "4XX", "5XX")) {
+            // no content 
+            throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "API error occurred", 
+                    Utils.extractByteArrayFromBody(_httpRes));
+        }
        throw new SDKError(
            _httpRes, 
            _httpRes.statusCode(), 
@@ -1403,19 +1545,11 @@ public class Playlists implements
            // no content 
            return _res;
        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400", "4XX", "5XX")) {
-            // no content 
-            throw new SDKError(
-                    _httpRes, 
-                    _httpRes.statusCode(), 
-                    "API error occurred", 
-                    Utils.extractByteArrayFromBody(_httpRes));
-        }
-        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "400")) {
            if (Utils.contentTypeMatches(_contentType, "application/json")) {
-                UploadPlaylistResponseBody _out = Utils.mapper().readValue(
+                UploadPlaylistBadRequest _out = Utils.mapper().readValue(
                    Utils.toUtf8AndClose(_httpRes.body()),
-                    new TypeReference<UploadPlaylistResponseBody>() {});
+                    new TypeReference<UploadPlaylistBadRequest>() {});
                    _out.withRawResponse(Optional.ofNullable(_httpRes));
                
                throw _out;
@@ -1427,6 +1561,30 @@ public class Playlists implements
                    Utils.extractByteArrayFromBody(_httpRes));
            }
        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "401")) {
+            if (Utils.contentTypeMatches(_contentType, "application/json")) {
+                UploadPlaylistUnauthorized _out = Utils.mapper().readValue(
+                    Utils.toUtf8AndClose(_httpRes.body()),
+                    new TypeReference<UploadPlaylistUnauthorized>() {});
+                    _out.withRawResponse(Optional.ofNullable(_httpRes));
+                
+                throw _out;
+            } else {
+                throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "Unexpected content-type received: " + _contentType, 
+                    Utils.extractByteArrayFromBody(_httpRes));
+            }
+        }
+        if (Utils.statusCodeMatches(_httpRes.statusCode(), "4XX", "5XX")) {
+            // no content 
+            throw new SDKError(
+                    _httpRes, 
+                    _httpRes.statusCode(), 
+                    "API error occurred", 
+                    Utils.extractByteArrayFromBody(_httpRes));
+        }
        throw new SDKError(
            _httpRes, 
            _httpRes.statusCode(),