ci: regenerated with OpenAPI Doc , Speakeasy CLI 1.456.1

src/sdk/models/errors/addplaylistcontents.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type AddPlaylistContentsPlaylistsErrors = {
   code?: number | undefined;
@@ -136,6 +139,27 @@ export namespace AddPlaylistContentsPlaylistsErrors$ {
   export type Outbound = AddPlaylistContentsPlaylistsErrors$Outbound;
 }
 
+export function addPlaylistContentsPlaylistsErrorsToJSON(
+  addPlaylistContentsPlaylistsErrors: AddPlaylistContentsPlaylistsErrors,
+): string {
+  return JSON.stringify(
+    AddPlaylistContentsPlaylistsErrors$outboundSchema.parse(
+      addPlaylistContentsPlaylistsErrors,
+    ),
+  );
+}
+
+export function addPlaylistContentsPlaylistsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<AddPlaylistContentsPlaylistsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      AddPlaylistContentsPlaylistsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddPlaylistContentsPlaylistsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const AddPlaylistContentsUnauthorized$inboundSchema: z.ZodType<
   AddPlaylistContentsUnauthorized,
@@ -238,6 +262,24 @@ export namespace AddPlaylistContentsErrors$ {
   export type Outbound = AddPlaylistContentsErrors$Outbound;
 }
 
+export function addPlaylistContentsErrorsToJSON(
+  addPlaylistContentsErrors: AddPlaylistContentsErrors,
+): string {
+  return JSON.stringify(
+    AddPlaylistContentsErrors$outboundSchema.parse(addPlaylistContentsErrors),
+  );
+}
+
+export function addPlaylistContentsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<AddPlaylistContentsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddPlaylistContentsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddPlaylistContentsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const AddPlaylistContentsBadRequest$inboundSchema: z.ZodType<
   AddPlaylistContentsBadRequest,

src/sdk/models/errors/applyupdates.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type ApplyUpdatesUpdaterErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace ApplyUpdatesUpdaterErrors$ {
   export type Outbound = ApplyUpdatesUpdaterErrors$Outbound;
 }
 
+export function applyUpdatesUpdaterErrorsToJSON(
+  applyUpdatesUpdaterErrors: ApplyUpdatesUpdaterErrors,
+): string {
+  return JSON.stringify(
+    ApplyUpdatesUpdaterErrors$outboundSchema.parse(applyUpdatesUpdaterErrors),
+  );
+}
+
+export function applyUpdatesUpdaterErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<ApplyUpdatesUpdaterErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ApplyUpdatesUpdaterErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ApplyUpdatesUpdaterErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const ApplyUpdatesUnauthorized$inboundSchema: z.ZodType<
   ApplyUpdatesUnauthorized,
@@ -235,6 +256,24 @@ export namespace ApplyUpdatesErrors$ {
   export type Outbound = ApplyUpdatesErrors$Outbound;
 }
 
+export function applyUpdatesErrorsToJSON(
+  applyUpdatesErrors: ApplyUpdatesErrors,
+): string {
+  return JSON.stringify(
+    ApplyUpdatesErrors$outboundSchema.parse(applyUpdatesErrors),
+  );
+}
+
+export function applyUpdatesErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<ApplyUpdatesErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ApplyUpdatesErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ApplyUpdatesErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const ApplyUpdatesBadRequest$inboundSchema: z.ZodType<
   ApplyUpdatesBadRequest,

src/sdk/models/errors/cancelserveractivities.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type CancelServerActivitiesActivitiesErrors = {
   code?: number | undefined;
@@ -137,6 +140,28 @@ export namespace CancelServerActivitiesActivitiesErrors$ {
   export type Outbound = CancelServerActivitiesActivitiesErrors$Outbound;
 }
 
+export function cancelServerActivitiesActivitiesErrorsToJSON(
+  cancelServerActivitiesActivitiesErrors:
+    CancelServerActivitiesActivitiesErrors,
+): string {
+  return JSON.stringify(
+    CancelServerActivitiesActivitiesErrors$outboundSchema.parse(
+      cancelServerActivitiesActivitiesErrors,
+    ),
+  );
+}
+
+export function cancelServerActivitiesActivitiesErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<CancelServerActivitiesActivitiesErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CancelServerActivitiesActivitiesErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CancelServerActivitiesActivitiesErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const CancelServerActivitiesUnauthorized$inboundSchema: z.ZodType<
   CancelServerActivitiesUnauthorized,
@@ -240,6 +265,26 @@ export namespace CancelServerActivitiesErrors$ {
   export type Outbound = CancelServerActivitiesErrors$Outbound;
 }
 
+export function cancelServerActivitiesErrorsToJSON(
+  cancelServerActivitiesErrors: CancelServerActivitiesErrors,
+): string {
+  return JSON.stringify(
+    CancelServerActivitiesErrors$outboundSchema.parse(
+      cancelServerActivitiesErrors,
+    ),
+  );
+}
+
+export function cancelServerActivitiesErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<CancelServerActivitiesErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CancelServerActivitiesErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CancelServerActivitiesErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const CancelServerActivitiesBadRequest$inboundSchema: z.ZodType<
   CancelServerActivitiesBadRequest,

src/sdk/models/errors/checkforupdates.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type CheckForUpdatesUpdaterErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace CheckForUpdatesUpdaterErrors$ {
   export type Outbound = CheckForUpdatesUpdaterErrors$Outbound;
 }
 
+export function checkForUpdatesUpdaterErrorsToJSON(
+  checkForUpdatesUpdaterErrors: CheckForUpdatesUpdaterErrors,
+): string {
+  return JSON.stringify(
+    CheckForUpdatesUpdaterErrors$outboundSchema.parse(
+      checkForUpdatesUpdaterErrors,
+    ),
+  );
+}
+
+export function checkForUpdatesUpdaterErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<CheckForUpdatesUpdaterErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CheckForUpdatesUpdaterErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CheckForUpdatesUpdaterErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const CheckForUpdatesUnauthorized$inboundSchema: z.ZodType<
   CheckForUpdatesUnauthorized,
@@ -235,6 +258,24 @@ export namespace CheckForUpdatesErrors$ {
   export type Outbound = CheckForUpdatesErrors$Outbound;
 }
 
+export function checkForUpdatesErrorsToJSON(
+  checkForUpdatesErrors: CheckForUpdatesErrors,
+): string {
+  return JSON.stringify(
+    CheckForUpdatesErrors$outboundSchema.parse(checkForUpdatesErrors),
+  );
+}
+
+export function checkForUpdatesErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<CheckForUpdatesErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CheckForUpdatesErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CheckForUpdatesErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const CheckForUpdatesBadRequest$inboundSchema: z.ZodType<
   CheckForUpdatesBadRequest,

src/sdk/models/errors/clearplaylistcontents.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type ClearPlaylistContentsPlaylistsErrors = {
   code?: number | undefined;
@@ -137,6 +140,27 @@ export namespace ClearPlaylistContentsPlaylistsErrors$ {
   export type Outbound = ClearPlaylistContentsPlaylistsErrors$Outbound;
 }
 
+export function clearPlaylistContentsPlaylistsErrorsToJSON(
+  clearPlaylistContentsPlaylistsErrors: ClearPlaylistContentsPlaylistsErrors,
+): string {
+  return JSON.stringify(
+    ClearPlaylistContentsPlaylistsErrors$outboundSchema.parse(
+      clearPlaylistContentsPlaylistsErrors,
+    ),
+  );
+}
+
+export function clearPlaylistContentsPlaylistsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<ClearPlaylistContentsPlaylistsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ClearPlaylistContentsPlaylistsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ClearPlaylistContentsPlaylistsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const ClearPlaylistContentsUnauthorized$inboundSchema: z.ZodType<
   ClearPlaylistContentsUnauthorized,
@@ -240,6 +264,26 @@ export namespace ClearPlaylistContentsErrors$ {
   export type Outbound = ClearPlaylistContentsErrors$Outbound;
 }
 
+export function clearPlaylistContentsErrorsToJSON(
+  clearPlaylistContentsErrors: ClearPlaylistContentsErrors,
+): string {
+  return JSON.stringify(
+    ClearPlaylistContentsErrors$outboundSchema.parse(
+      clearPlaylistContentsErrors,
+    ),
+  );
+}
+
+export function clearPlaylistContentsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<ClearPlaylistContentsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ClearPlaylistContentsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ClearPlaylistContentsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const ClearPlaylistContentsBadRequest$inboundSchema: z.ZodType<
   ClearPlaylistContentsBadRequest,

src/sdk/models/errors/createplaylist.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type CreatePlaylistPlaylistsErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace CreatePlaylistPlaylistsErrors$ {
   export type Outbound = CreatePlaylistPlaylistsErrors$Outbound;
 }
 
+export function createPlaylistPlaylistsErrorsToJSON(
+  createPlaylistPlaylistsErrors: CreatePlaylistPlaylistsErrors,
+): string {
+  return JSON.stringify(
+    CreatePlaylistPlaylistsErrors$outboundSchema.parse(
+      createPlaylistPlaylistsErrors,
+    ),
+  );
+}
+
+export function createPlaylistPlaylistsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreatePlaylistPlaylistsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreatePlaylistPlaylistsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreatePlaylistPlaylistsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreatePlaylistUnauthorized$inboundSchema: z.ZodType<
   CreatePlaylistUnauthorized,
@@ -236,6 +259,24 @@ export namespace CreatePlaylistErrors$ {
   export type Outbound = CreatePlaylistErrors$Outbound;
 }
 
+export function createPlaylistErrorsToJSON(
+  createPlaylistErrors: CreatePlaylistErrors,
+): string {
+  return JSON.stringify(
+    CreatePlaylistErrors$outboundSchema.parse(createPlaylistErrors),
+  );
+}
+
+export function createPlaylistErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreatePlaylistErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreatePlaylistErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreatePlaylistErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreatePlaylistBadRequest$inboundSchema: z.ZodType<
   CreatePlaylistBadRequest,

src/sdk/models/errors/deletelibrary.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type DeleteLibraryLibraryErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace DeleteLibraryLibraryErrors$ {
   export type Outbound = DeleteLibraryLibraryErrors$Outbound;
 }
 
+export function deleteLibraryLibraryErrorsToJSON(
+  deleteLibraryLibraryErrors: DeleteLibraryLibraryErrors,
+): string {
+  return JSON.stringify(
+    DeleteLibraryLibraryErrors$outboundSchema.parse(deleteLibraryLibraryErrors),
+  );
+}
+
+export function deleteLibraryLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteLibraryLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteLibraryLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteLibraryLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const DeleteLibraryUnauthorized$inboundSchema: z.ZodType<
   DeleteLibraryUnauthorized,
@@ -235,6 +256,24 @@ export namespace DeleteLibraryErrors$ {
   export type Outbound = DeleteLibraryErrors$Outbound;
 }
 
+export function deleteLibraryErrorsToJSON(
+  deleteLibraryErrors: DeleteLibraryErrors,
+): string {
+  return JSON.stringify(
+    DeleteLibraryErrors$outboundSchema.parse(deleteLibraryErrors),
+  );
+}
+
+export function deleteLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const DeleteLibraryBadRequest$inboundSchema: z.ZodType<
   DeleteLibraryBadRequest,

src/sdk/models/errors/deleteplaylist.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type DeletePlaylistPlaylistsErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace DeletePlaylistPlaylistsErrors$ {
   export type Outbound = DeletePlaylistPlaylistsErrors$Outbound;
 }
 
+export function deletePlaylistPlaylistsErrorsToJSON(
+  deletePlaylistPlaylistsErrors: DeletePlaylistPlaylistsErrors,
+): string {
+  return JSON.stringify(
+    DeletePlaylistPlaylistsErrors$outboundSchema.parse(
+      deletePlaylistPlaylistsErrors,
+    ),
+  );
+}
+
+export function deletePlaylistPlaylistsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<DeletePlaylistPlaylistsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeletePlaylistPlaylistsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeletePlaylistPlaylistsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const DeletePlaylistUnauthorized$inboundSchema: z.ZodType<
   DeletePlaylistUnauthorized,
@@ -236,6 +259,24 @@ export namespace DeletePlaylistErrors$ {
   export type Outbound = DeletePlaylistErrors$Outbound;
 }
 
+export function deletePlaylistErrorsToJSON(
+  deletePlaylistErrors: DeletePlaylistErrors,
+): string {
+  return JSON.stringify(
+    DeletePlaylistErrors$outboundSchema.parse(deletePlaylistErrors),
+  );
+}
+
+export function deletePlaylistErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<DeletePlaylistErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeletePlaylistErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeletePlaylistErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const DeletePlaylistBadRequest$inboundSchema: z.ZodType<
   DeletePlaylistBadRequest,

src/sdk/models/errors/enablepapertrail.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type EnablePaperTrailLogErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace EnablePaperTrailLogErrors$ {
   export type Outbound = EnablePaperTrailLogErrors$Outbound;
 }
 
+export function enablePaperTrailLogErrorsToJSON(
+  enablePaperTrailLogErrors: EnablePaperTrailLogErrors,
+): string {
+  return JSON.stringify(
+    EnablePaperTrailLogErrors$outboundSchema.parse(enablePaperTrailLogErrors),
+  );
+}
+
+export function enablePaperTrailLogErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<EnablePaperTrailLogErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnablePaperTrailLogErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnablePaperTrailLogErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const EnablePaperTrailUnauthorized$inboundSchema: z.ZodType<
   EnablePaperTrailUnauthorized,
@@ -235,6 +256,24 @@ export namespace EnablePaperTrailErrors$ {
   export type Outbound = EnablePaperTrailErrors$Outbound;
 }
 
+export function enablePaperTrailErrorsToJSON(
+  enablePaperTrailErrors: EnablePaperTrailErrors,
+): string {
+  return JSON.stringify(
+    EnablePaperTrailErrors$outboundSchema.parse(enablePaperTrailErrors),
+  );
+}
+
+export function enablePaperTrailErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<EnablePaperTrailErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnablePaperTrailErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnablePaperTrailErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const EnablePaperTrailBadRequest$inboundSchema: z.ZodType<
   EnablePaperTrailBadRequest,

src/sdk/models/errors/getalllibraries.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetAllLibrariesLibraryErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetAllLibrariesLibraryErrors$ {
   export type Outbound = GetAllLibrariesLibraryErrors$Outbound;
 }
 
+export function getAllLibrariesLibraryErrorsToJSON(
+  getAllLibrariesLibraryErrors: GetAllLibrariesLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetAllLibrariesLibraryErrors$outboundSchema.parse(
+      getAllLibrariesLibraryErrors,
+    ),
+  );
+}
+
+export function getAllLibrariesLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAllLibrariesLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAllLibrariesLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAllLibrariesLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetAllLibrariesUnauthorized$inboundSchema: z.ZodType<
   GetAllLibrariesUnauthorized,
@@ -235,6 +258,24 @@ export namespace GetAllLibrariesErrors$ {
   export type Outbound = GetAllLibrariesErrors$Outbound;
 }
 
+export function getAllLibrariesErrorsToJSON(
+  getAllLibrariesErrors: GetAllLibrariesErrors,
+): string {
+  return JSON.stringify(
+    GetAllLibrariesErrors$outboundSchema.parse(getAllLibrariesErrors),
+  );
+}
+
+export function getAllLibrariesErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAllLibrariesErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAllLibrariesErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAllLibrariesErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetAllLibrariesBadRequest$inboundSchema: z.ZodType<
   GetAllLibrariesBadRequest,

src/sdk/models/errors/getavailableclients.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetAvailableClientsServerErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetAvailableClientsServerErrors$ {
   export type Outbound = GetAvailableClientsServerErrors$Outbound;
 }
 
+export function getAvailableClientsServerErrorsToJSON(
+  getAvailableClientsServerErrors: GetAvailableClientsServerErrors,
+): string {
+  return JSON.stringify(
+    GetAvailableClientsServerErrors$outboundSchema.parse(
+      getAvailableClientsServerErrors,
+    ),
+  );
+}
+
+export function getAvailableClientsServerErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAvailableClientsServerErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAvailableClientsServerErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAvailableClientsServerErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetAvailableClientsUnauthorized$inboundSchema: z.ZodType<
   GetAvailableClientsUnauthorized,
@@ -236,6 +259,24 @@ export namespace GetAvailableClientsErrors$ {
   export type Outbound = GetAvailableClientsErrors$Outbound;
 }
 
+export function getAvailableClientsErrorsToJSON(
+  getAvailableClientsErrors: GetAvailableClientsErrors,
+): string {
+  return JSON.stringify(
+    GetAvailableClientsErrors$outboundSchema.parse(getAvailableClientsErrors),
+  );
+}
+
+export function getAvailableClientsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAvailableClientsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAvailableClientsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAvailableClientsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetAvailableClientsBadRequest$inboundSchema: z.ZodType<
   GetAvailableClientsBadRequest,

src/sdk/models/errors/getbandwidthstatistics.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetBandwidthStatisticsStatisticsErrors = {
   code?: number | undefined;
@@ -137,6 +140,28 @@ export namespace GetBandwidthStatisticsStatisticsErrors$ {
   export type Outbound = GetBandwidthStatisticsStatisticsErrors$Outbound;
 }
 
+export function getBandwidthStatisticsStatisticsErrorsToJSON(
+  getBandwidthStatisticsStatisticsErrors:
+    GetBandwidthStatisticsStatisticsErrors,
+): string {
+  return JSON.stringify(
+    GetBandwidthStatisticsStatisticsErrors$outboundSchema.parse(
+      getBandwidthStatisticsStatisticsErrors,
+    ),
+  );
+}
+
+export function getBandwidthStatisticsStatisticsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetBandwidthStatisticsStatisticsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetBandwidthStatisticsStatisticsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetBandwidthStatisticsStatisticsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetBandwidthStatisticsUnauthorized$inboundSchema: z.ZodType<
   GetBandwidthStatisticsUnauthorized,
@@ -240,6 +265,26 @@ export namespace GetBandwidthStatisticsErrors$ {
   export type Outbound = GetBandwidthStatisticsErrors$Outbound;
 }
 
+export function getBandwidthStatisticsErrorsToJSON(
+  getBandwidthStatisticsErrors: GetBandwidthStatisticsErrors,
+): string {
+  return JSON.stringify(
+    GetBandwidthStatisticsErrors$outboundSchema.parse(
+      getBandwidthStatisticsErrors,
+    ),
+  );
+}
+
+export function getBandwidthStatisticsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetBandwidthStatisticsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetBandwidthStatisticsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetBandwidthStatisticsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetBandwidthStatisticsBadRequest$inboundSchema: z.ZodType<
   GetBandwidthStatisticsBadRequest,

src/sdk/models/errors/getbannerimage.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetBannerImageMediaErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetBannerImageMediaErrors$ {
   export type Outbound = GetBannerImageMediaErrors$Outbound;
 }
 
+export function getBannerImageMediaErrorsToJSON(
+  getBannerImageMediaErrors: GetBannerImageMediaErrors,
+): string {
+  return JSON.stringify(
+    GetBannerImageMediaErrors$outboundSchema.parse(getBannerImageMediaErrors),
+  );
+}
+
+export function getBannerImageMediaErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetBannerImageMediaErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetBannerImageMediaErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetBannerImageMediaErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetBannerImageUnauthorized$inboundSchema: z.ZodType<
   GetBannerImageUnauthorized,
@@ -235,6 +256,24 @@ export namespace GetBannerImageErrors$ {
   export type Outbound = GetBannerImageErrors$Outbound;
 }
 
+export function getBannerImageErrorsToJSON(
+  getBannerImageErrors: GetBannerImageErrors,
+): string {
+  return JSON.stringify(
+    GetBannerImageErrors$outboundSchema.parse(getBannerImageErrors),
+  );
+}
+
+export function getBannerImageErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetBannerImageErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetBannerImageErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetBannerImageErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetBannerImageBadRequest$inboundSchema: z.ZodType<
   GetBannerImageBadRequest,

src/sdk/models/errors/getbutlertasks.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetButlerTasksButlerErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetButlerTasksButlerErrors$ {
   export type Outbound = GetButlerTasksButlerErrors$Outbound;
 }
 
+export function getButlerTasksButlerErrorsToJSON(
+  getButlerTasksButlerErrors: GetButlerTasksButlerErrors,
+): string {
+  return JSON.stringify(
+    GetButlerTasksButlerErrors$outboundSchema.parse(getButlerTasksButlerErrors),
+  );
+}
+
+export function getButlerTasksButlerErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetButlerTasksButlerErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetButlerTasksButlerErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetButlerTasksButlerErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetButlerTasksUnauthorized$inboundSchema: z.ZodType<
   GetButlerTasksUnauthorized,
@@ -235,6 +256,24 @@ export namespace GetButlerTasksErrors$ {
   export type Outbound = GetButlerTasksErrors$Outbound;
 }
 
+export function getButlerTasksErrorsToJSON(
+  getButlerTasksErrors: GetButlerTasksErrors,
+): string {
+  return JSON.stringify(
+    GetButlerTasksErrors$outboundSchema.parse(getButlerTasksErrors),
+  );
+}
+
+export function getButlerTasksErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetButlerTasksErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetButlerTasksErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetButlerTasksErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetButlerTasksBadRequest$inboundSchema: z.ZodType<
   GetButlerTasksBadRequest,

src/sdk/models/errors/getcompanionsdata.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetCompanionsDataPlexErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetCompanionsDataPlexErrors$ {
   export type Outbound = GetCompanionsDataPlexErrors$Outbound;
 }
 
+export function getCompanionsDataPlexErrorsToJSON(
+  getCompanionsDataPlexErrors: GetCompanionsDataPlexErrors,
+): string {
+  return JSON.stringify(
+    GetCompanionsDataPlexErrors$outboundSchema.parse(
+      getCompanionsDataPlexErrors,
+    ),
+  );
+}
+
+export function getCompanionsDataPlexErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetCompanionsDataPlexErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetCompanionsDataPlexErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetCompanionsDataPlexErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetCompanionsDataUnauthorized$inboundSchema: z.ZodType<
   GetCompanionsDataUnauthorized,
@@ -235,6 +258,24 @@ export namespace GetCompanionsDataErrors$ {
   export type Outbound = GetCompanionsDataErrors$Outbound;
 }
 
+export function getCompanionsDataErrorsToJSON(
+  getCompanionsDataErrors: GetCompanionsDataErrors,
+): string {
+  return JSON.stringify(
+    GetCompanionsDataErrors$outboundSchema.parse(getCompanionsDataErrors),
+  );
+}
+
+export function getCompanionsDataErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetCompanionsDataErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetCompanionsDataErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetCompanionsDataErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetCompanionsDataBadRequest$inboundSchema: z.ZodType<
   GetCompanionsDataBadRequest,

src/sdk/models/errors/getdevices.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetDevicesServerErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetDevicesServerErrors$ {
   export type Outbound = GetDevicesServerErrors$Outbound;
 }
 
+export function getDevicesServerErrorsToJSON(
+  getDevicesServerErrors: GetDevicesServerErrors,
+): string {
+  return JSON.stringify(
+    GetDevicesServerErrors$outboundSchema.parse(getDevicesServerErrors),
+  );
+}
+
+export function getDevicesServerErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetDevicesServerErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetDevicesServerErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetDevicesServerErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetDevicesUnauthorized$inboundSchema: z.ZodType<
   GetDevicesUnauthorized,
@@ -235,6 +256,24 @@ export namespace GetDevicesErrors$ {
   export type Outbound = GetDevicesErrors$Outbound;
 }
 
+export function getDevicesErrorsToJSON(
+  getDevicesErrors: GetDevicesErrors,
+): string {
+  return JSON.stringify(
+    GetDevicesErrors$outboundSchema.parse(getDevicesErrors),
+  );
+}
+
+export function getDevicesErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetDevicesErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetDevicesErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetDevicesErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetDevicesBadRequest$inboundSchema: z.ZodType<
   GetDevicesBadRequest,

src/sdk/models/errors/getfilehash.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetFileHashLibraryErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetFileHashLibraryErrors$ {
   export type Outbound = GetFileHashLibraryErrors$Outbound;
 }
 
+export function getFileHashLibraryErrorsToJSON(
+  getFileHashLibraryErrors: GetFileHashLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetFileHashLibraryErrors$outboundSchema.parse(getFileHashLibraryErrors),
+  );
+}
+
+export function getFileHashLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetFileHashLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetFileHashLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetFileHashLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetFileHashUnauthorized$inboundSchema: z.ZodType<
   GetFileHashUnauthorized,
@@ -235,6 +256,24 @@ export namespace GetFileHashErrors$ {
   export type Outbound = GetFileHashErrors$Outbound;
 }
 
+export function getFileHashErrorsToJSON(
+  getFileHashErrors: GetFileHashErrors,
+): string {
+  return JSON.stringify(
+    GetFileHashErrors$outboundSchema.parse(getFileHashErrors),
+  );
+}
+
+export function getFileHashErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetFileHashErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetFileHashErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetFileHashErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetFileHashBadRequest$inboundSchema: z.ZodType<
   GetFileHashBadRequest,

src/sdk/models/errors/getgeodata.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetGeoDataPlexErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetGeoDataPlexErrors$ {
   export type Outbound = GetGeoDataPlexErrors$Outbound;
 }
 
+export function getGeoDataPlexErrorsToJSON(
+  getGeoDataPlexErrors: GetGeoDataPlexErrors,
+): string {
+  return JSON.stringify(
+    GetGeoDataPlexErrors$outboundSchema.parse(getGeoDataPlexErrors),
+  );
+}
+
+export function getGeoDataPlexErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetGeoDataPlexErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetGeoDataPlexErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetGeoDataPlexErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetGeoDataUnauthorized$inboundSchema: z.ZodType<
   GetGeoDataUnauthorized,
@@ -234,6 +255,24 @@ export namespace GetGeoDataErrors$ {
   export type Outbound = GetGeoDataErrors$Outbound;
 }
 
+export function getGeoDataErrorsToJSON(
+  getGeoDataErrors: GetGeoDataErrors,
+): string {
+  return JSON.stringify(
+    GetGeoDataErrors$outboundSchema.parse(getGeoDataErrors),
+  );
+}
+
+export function getGeoDataErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetGeoDataErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetGeoDataErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetGeoDataErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetGeoDataBadRequest$inboundSchema: z.ZodType<
   GetGeoDataBadRequest,

src/sdk/models/errors/getglobalhubs.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetGlobalHubsHubsErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetGlobalHubsHubsErrors$ {
   export type Outbound = GetGlobalHubsHubsErrors$Outbound;
 }
 
+export function getGlobalHubsHubsErrorsToJSON(
+  getGlobalHubsHubsErrors: GetGlobalHubsHubsErrors,
+): string {
+  return JSON.stringify(
+    GetGlobalHubsHubsErrors$outboundSchema.parse(getGlobalHubsHubsErrors),
+  );
+}
+
+export function getGlobalHubsHubsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetGlobalHubsHubsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetGlobalHubsHubsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetGlobalHubsHubsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetGlobalHubsUnauthorized$inboundSchema: z.ZodType<
   GetGlobalHubsUnauthorized,
@@ -235,6 +256,24 @@ export namespace GetGlobalHubsErrors$ {
   export type Outbound = GetGlobalHubsErrors$Outbound;
 }
 
+export function getGlobalHubsErrorsToJSON(
+  getGlobalHubsErrors: GetGlobalHubsErrors,
+): string {
+  return JSON.stringify(
+    GetGlobalHubsErrors$outboundSchema.parse(getGlobalHubsErrors),
+  );
+}
+
+export function getGlobalHubsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetGlobalHubsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetGlobalHubsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetGlobalHubsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetGlobalHubsBadRequest$inboundSchema: z.ZodType<
   GetGlobalHubsBadRequest,

src/sdk/models/errors/gethomedata.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetHomeDataPlexErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetHomeDataPlexErrors$ {
   export type Outbound = GetHomeDataPlexErrors$Outbound;
 }
 
+export function getHomeDataPlexErrorsToJSON(
+  getHomeDataPlexErrors: GetHomeDataPlexErrors,
+): string {
+  return JSON.stringify(
+    GetHomeDataPlexErrors$outboundSchema.parse(getHomeDataPlexErrors),
+  );
+}
+
+export function getHomeDataPlexErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetHomeDataPlexErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetHomeDataPlexErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetHomeDataPlexErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetHomeDataUnauthorized$inboundSchema: z.ZodType<
   GetHomeDataUnauthorized,
@@ -234,6 +255,24 @@ export namespace GetHomeDataErrors$ {
   export type Outbound = GetHomeDataErrors$Outbound;
 }
 
+export function getHomeDataErrorsToJSON(
+  getHomeDataErrors: GetHomeDataErrors,
+): string {
+  return JSON.stringify(
+    GetHomeDataErrors$outboundSchema.parse(getHomeDataErrors),
+  );
+}
+
+export function getHomeDataErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetHomeDataErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetHomeDataErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetHomeDataErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetHomeDataBadRequest$inboundSchema: z.ZodType<
   GetHomeDataBadRequest,

src/sdk/models/errors/getlibrarydetails.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetLibraryDetailsLibraryErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetLibraryDetailsLibraryErrors$ {
   export type Outbound = GetLibraryDetailsLibraryErrors$Outbound;
 }
 
+export function getLibraryDetailsLibraryErrorsToJSON(
+  getLibraryDetailsLibraryErrors: GetLibraryDetailsLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetLibraryDetailsLibraryErrors$outboundSchema.parse(
+      getLibraryDetailsLibraryErrors,
+    ),
+  );
+}
+
+export function getLibraryDetailsLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryDetailsLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryDetailsLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryDetailsLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryDetailsUnauthorized$inboundSchema: z.ZodType<
   GetLibraryDetailsUnauthorized,
@@ -236,6 +259,24 @@ export namespace GetLibraryDetailsErrors$ {
   export type Outbound = GetLibraryDetailsErrors$Outbound;
 }
 
+export function getLibraryDetailsErrorsToJSON(
+  getLibraryDetailsErrors: GetLibraryDetailsErrors,
+): string {
+  return JSON.stringify(
+    GetLibraryDetailsErrors$outboundSchema.parse(getLibraryDetailsErrors),
+  );
+}
+
+export function getLibraryDetailsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryDetailsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryDetailsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryDetailsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryDetailsBadRequest$inboundSchema: z.ZodType<
   GetLibraryDetailsBadRequest,

src/sdk/models/errors/getlibraryhubs.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetLibraryHubsHubsErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetLibraryHubsHubsErrors$ {
   export type Outbound = GetLibraryHubsHubsErrors$Outbound;
 }
 
+export function getLibraryHubsHubsErrorsToJSON(
+  getLibraryHubsHubsErrors: GetLibraryHubsHubsErrors,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsHubsErrors$outboundSchema.parse(getLibraryHubsHubsErrors),
+  );
+}
+
+export function getLibraryHubsHubsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsHubsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsHubsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsHubsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsUnauthorized$inboundSchema: z.ZodType<
   GetLibraryHubsUnauthorized,
@@ -235,6 +256,24 @@ export namespace GetLibraryHubsErrors$ {
   export type Outbound = GetLibraryHubsErrors$Outbound;
 }
 
+export function getLibraryHubsErrorsToJSON(
+  getLibraryHubsErrors: GetLibraryHubsErrors,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsErrors$outboundSchema.parse(getLibraryHubsErrors),
+  );
+}
+
+export function getLibraryHubsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsBadRequest$inboundSchema: z.ZodType<
   GetLibraryHubsBadRequest,

src/sdk/models/errors/getlibraryitems.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetLibraryItemsLibraryErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetLibraryItemsLibraryErrors$ {
   export type Outbound = GetLibraryItemsLibraryErrors$Outbound;
 }
 
+export function getLibraryItemsLibraryErrorsToJSON(
+  getLibraryItemsLibraryErrors: GetLibraryItemsLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsLibraryErrors$outboundSchema.parse(
+      getLibraryItemsLibraryErrors,
+    ),
+  );
+}
+
+export function getLibraryItemsLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsUnauthorized$inboundSchema: z.ZodType<
   GetLibraryItemsUnauthorized,
@@ -235,6 +258,24 @@ export namespace GetLibraryItemsErrors$ {
   export type Outbound = GetLibraryItemsErrors$Outbound;
 }
 
+export function getLibraryItemsErrorsToJSON(
+  getLibraryItemsErrors: GetLibraryItemsErrors,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsErrors$outboundSchema.parse(getLibraryItemsErrors),
+  );
+}
+
+export function getLibraryItemsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsBadRequest$inboundSchema: z.ZodType<
   GetLibraryItemsBadRequest,

src/sdk/models/errors/getmediaproviders.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetMediaProvidersServerErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetMediaProvidersServerErrors$ {
   export type Outbound = GetMediaProvidersServerErrors$Outbound;
 }
 
+export function getMediaProvidersServerErrorsToJSON(
+  getMediaProvidersServerErrors: GetMediaProvidersServerErrors,
+): string {
+  return JSON.stringify(
+    GetMediaProvidersServerErrors$outboundSchema.parse(
+      getMediaProvidersServerErrors,
+    ),
+  );
+}
+
+export function getMediaProvidersServerErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMediaProvidersServerErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMediaProvidersServerErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMediaProvidersServerErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMediaProvidersUnauthorized$inboundSchema: z.ZodType<
   GetMediaProvidersUnauthorized,
@@ -236,6 +259,24 @@ export namespace GetMediaProvidersErrors$ {
   export type Outbound = GetMediaProvidersErrors$Outbound;
 }
 
+export function getMediaProvidersErrorsToJSON(
+  getMediaProvidersErrors: GetMediaProvidersErrors,
+): string {
+  return JSON.stringify(
+    GetMediaProvidersErrors$outboundSchema.parse(getMediaProvidersErrors),
+  );
+}
+
+export function getMediaProvidersErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMediaProvidersErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMediaProvidersErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMediaProvidersErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMediaProvidersBadRequest$inboundSchema: z.ZodType<
   GetMediaProvidersBadRequest,

src/sdk/models/errors/getmetadatabyratingkey.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetMetaDataByRatingKeyLibraryErrors = {
   code?: number | undefined;
@@ -137,6 +140,27 @@ export namespace GetMetaDataByRatingKeyLibraryErrors$ {
   export type Outbound = GetMetaDataByRatingKeyLibraryErrors$Outbound;
 }
 
+export function getMetaDataByRatingKeyLibraryErrorsToJSON(
+  getMetaDataByRatingKeyLibraryErrors: GetMetaDataByRatingKeyLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyLibraryErrors$outboundSchema.parse(
+      getMetaDataByRatingKeyLibraryErrors,
+    ),
+  );
+}
+
+export function getMetaDataByRatingKeyLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetMetaDataByRatingKeyLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyUnauthorized$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyUnauthorized,
@@ -240,6 +264,26 @@ export namespace GetMetaDataByRatingKeyErrors$ {
   export type Outbound = GetMetaDataByRatingKeyErrors$Outbound;
 }
 
+export function getMetaDataByRatingKeyErrorsToJSON(
+  getMetaDataByRatingKeyErrors: GetMetaDataByRatingKeyErrors,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyErrors$outboundSchema.parse(
+      getMetaDataByRatingKeyErrors,
+    ),
+  );
+}
+
+export function getMetaDataByRatingKeyErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetaDataByRatingKeyErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyBadRequest$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyBadRequest,

src/sdk/models/errors/getmetadatachildren.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetMetadataChildrenLibraryErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetMetadataChildrenLibraryErrors$ {
   export type Outbound = GetMetadataChildrenLibraryErrors$Outbound;
 }
 
+export function getMetadataChildrenLibraryErrorsToJSON(
+  getMetadataChildrenLibraryErrors: GetMetadataChildrenLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetMetadataChildrenLibraryErrors$outboundSchema.parse(
+      getMetadataChildrenLibraryErrors,
+    ),
+  );
+}
+
+export function getMetadataChildrenLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetadataChildrenLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetadataChildrenLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetadataChildrenLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetadataChildrenUnauthorized$inboundSchema: z.ZodType<
   GetMetadataChildrenUnauthorized,
@@ -236,6 +259,24 @@ export namespace GetMetadataChildrenErrors$ {
   export type Outbound = GetMetadataChildrenErrors$Outbound;
 }
 
+export function getMetadataChildrenErrorsToJSON(
+  getMetadataChildrenErrors: GetMetadataChildrenErrors,
+): string {
+  return JSON.stringify(
+    GetMetadataChildrenErrors$outboundSchema.parse(getMetadataChildrenErrors),
+  );
+}
+
+export function getMetadataChildrenErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetadataChildrenErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetadataChildrenErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetadataChildrenErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetadataChildrenBadRequest$inboundSchema: z.ZodType<
   GetMetadataChildrenBadRequest,

src/sdk/models/errors/getmyplexaccount.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetMyPlexAccountServerErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetMyPlexAccountServerErrors$ {
   export type Outbound = GetMyPlexAccountServerErrors$Outbound;
 }
 
+export function getMyPlexAccountServerErrorsToJSON(
+  getMyPlexAccountServerErrors: GetMyPlexAccountServerErrors,
+): string {
+  return JSON.stringify(
+    GetMyPlexAccountServerErrors$outboundSchema.parse(
+      getMyPlexAccountServerErrors,
+    ),
+  );
+}
+
+export function getMyPlexAccountServerErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMyPlexAccountServerErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMyPlexAccountServerErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMyPlexAccountServerErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMyPlexAccountUnauthorized$inboundSchema: z.ZodType<
   GetMyPlexAccountUnauthorized,
@@ -235,6 +258,24 @@ export namespace GetMyPlexAccountErrors$ {
   export type Outbound = GetMyPlexAccountErrors$Outbound;
 }
 
+export function getMyPlexAccountErrorsToJSON(
+  getMyPlexAccountErrors: GetMyPlexAccountErrors,
+): string {
+  return JSON.stringify(
+    GetMyPlexAccountErrors$outboundSchema.parse(getMyPlexAccountErrors),
+  );
+}
+
+export function getMyPlexAccountErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMyPlexAccountErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMyPlexAccountErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMyPlexAccountErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMyPlexAccountBadRequest$inboundSchema: z.ZodType<
   GetMyPlexAccountBadRequest,

src/sdk/models/errors/getondeck.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetOnDeckLibraryErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetOnDeckLibraryErrors$ {
   export type Outbound = GetOnDeckLibraryErrors$Outbound;
 }
 
+export function getOnDeckLibraryErrorsToJSON(
+  getOnDeckLibraryErrors: GetOnDeckLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetOnDeckLibraryErrors$outboundSchema.parse(getOnDeckLibraryErrors),
+  );
+}
+
+export function getOnDeckLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOnDeckLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetOnDeckLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOnDeckLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetOnDeckUnauthorized$inboundSchema: z.ZodType<
   GetOnDeckUnauthorized,
@@ -235,6 +256,22 @@ export namespace GetOnDeckErrors$ {
   export type Outbound = GetOnDeckErrors$Outbound;
 }
 
+export function getOnDeckErrorsToJSON(
+  getOnDeckErrors: GetOnDeckErrors,
+): string {
+  return JSON.stringify(GetOnDeckErrors$outboundSchema.parse(getOnDeckErrors));
+}
+
+export function getOnDeckErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOnDeckErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetOnDeckErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOnDeckErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetOnDeckBadRequest$inboundSchema: z.ZodType<
   GetOnDeckBadRequest,

src/sdk/models/errors/getpin.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetPinErrors = {
   code?: number | undefined;
@@ -91,6 +94,20 @@ export namespace GetPinErrors$ {
   export type Outbound = GetPinErrors$Outbound;
 }
 
+export function getPinErrorsToJSON(getPinErrors: GetPinErrors): string {
+  return JSON.stringify(GetPinErrors$outboundSchema.parse(getPinErrors));
+}
+
+export function getPinErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPinErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPinErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPinErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetPinBadRequest$inboundSchema: z.ZodType<
   GetPinBadRequest,

src/sdk/models/errors/getplaylist.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetPlaylistPlaylistsErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetPlaylistPlaylistsErrors$ {
   export type Outbound = GetPlaylistPlaylistsErrors$Outbound;
 }
 
+export function getPlaylistPlaylistsErrorsToJSON(
+  getPlaylistPlaylistsErrors: GetPlaylistPlaylistsErrors,
+): string {
+  return JSON.stringify(
+    GetPlaylistPlaylistsErrors$outboundSchema.parse(getPlaylistPlaylistsErrors),
+  );
+}
+
+export function getPlaylistPlaylistsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPlaylistPlaylistsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPlaylistPlaylistsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPlaylistPlaylistsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetPlaylistUnauthorized$inboundSchema: z.ZodType<
   GetPlaylistUnauthorized,
@@ -235,6 +256,24 @@ export namespace GetPlaylistErrors$ {
   export type Outbound = GetPlaylistErrors$Outbound;
 }
 
+export function getPlaylistErrorsToJSON(
+  getPlaylistErrors: GetPlaylistErrors,
+): string {
+  return JSON.stringify(
+    GetPlaylistErrors$outboundSchema.parse(getPlaylistErrors),
+  );
+}
+
+export function getPlaylistErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPlaylistErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPlaylistErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPlaylistErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetPlaylistBadRequest$inboundSchema: z.ZodType<
   GetPlaylistBadRequest,

src/sdk/models/errors/getplaylistcontents.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetPlaylistContentsPlaylistsErrors = {
   code?: number | undefined;
@@ -136,6 +139,27 @@ export namespace GetPlaylistContentsPlaylistsErrors$ {
   export type Outbound = GetPlaylistContentsPlaylistsErrors$Outbound;
 }
 
+export function getPlaylistContentsPlaylistsErrorsToJSON(
+  getPlaylistContentsPlaylistsErrors: GetPlaylistContentsPlaylistsErrors,
+): string {
+  return JSON.stringify(
+    GetPlaylistContentsPlaylistsErrors$outboundSchema.parse(
+      getPlaylistContentsPlaylistsErrors,
+    ),
+  );
+}
+
+export function getPlaylistContentsPlaylistsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPlaylistContentsPlaylistsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetPlaylistContentsPlaylistsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPlaylistContentsPlaylistsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetPlaylistContentsUnauthorized$inboundSchema: z.ZodType<
   GetPlaylistContentsUnauthorized,
@@ -238,6 +262,24 @@ export namespace GetPlaylistContentsErrors$ {
   export type Outbound = GetPlaylistContentsErrors$Outbound;
 }
 
+export function getPlaylistContentsErrorsToJSON(
+  getPlaylistContentsErrors: GetPlaylistContentsErrors,
+): string {
+  return JSON.stringify(
+    GetPlaylistContentsErrors$outboundSchema.parse(getPlaylistContentsErrors),
+  );
+}
+
+export function getPlaylistContentsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPlaylistContentsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPlaylistContentsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPlaylistContentsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetPlaylistContentsBadRequest$inboundSchema: z.ZodType<
   GetPlaylistContentsBadRequest,

src/sdk/models/errors/getplaylists.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetPlaylistsPlaylistsErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetPlaylistsPlaylistsErrors$ {
   export type Outbound = GetPlaylistsPlaylistsErrors$Outbound;
 }
 
+export function getPlaylistsPlaylistsErrorsToJSON(
+  getPlaylistsPlaylistsErrors: GetPlaylistsPlaylistsErrors,
+): string {
+  return JSON.stringify(
+    GetPlaylistsPlaylistsErrors$outboundSchema.parse(
+      getPlaylistsPlaylistsErrors,
+    ),
+  );
+}
+
+export function getPlaylistsPlaylistsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPlaylistsPlaylistsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPlaylistsPlaylistsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPlaylistsPlaylistsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetPlaylistsUnauthorized$inboundSchema: z.ZodType<
   GetPlaylistsUnauthorized,
@@ -235,6 +258,24 @@ export namespace GetPlaylistsErrors$ {
   export type Outbound = GetPlaylistsErrors$Outbound;
 }
 
+export function getPlaylistsErrorsToJSON(
+  getPlaylistsErrors: GetPlaylistsErrors,
+): string {
+  return JSON.stringify(
+    GetPlaylistsErrors$outboundSchema.parse(getPlaylistsErrors),
+  );
+}
+
+export function getPlaylistsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetPlaylistsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetPlaylistsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetPlaylistsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetPlaylistsBadRequest$inboundSchema: z.ZodType<
   GetPlaylistsBadRequest,

src/sdk/models/errors/getrecentlyaddedlibrary.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetRecentlyAddedLibraryLibraryErrors = {
   code?: number | undefined;
@@ -137,6 +140,27 @@ export namespace GetRecentlyAddedLibraryLibraryErrors$ {
   export type Outbound = GetRecentlyAddedLibraryLibraryErrors$Outbound;
 }
 
+export function getRecentlyAddedLibraryLibraryErrorsToJSON(
+  getRecentlyAddedLibraryLibraryErrors: GetRecentlyAddedLibraryLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetRecentlyAddedLibraryLibraryErrors$outboundSchema.parse(
+      getRecentlyAddedLibraryLibraryErrors,
+    ),
+  );
+}
+
+export function getRecentlyAddedLibraryLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetRecentlyAddedLibraryLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetRecentlyAddedLibraryLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetRecentlyAddedLibraryLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetRecentlyAddedLibraryUnauthorized$inboundSchema: z.ZodType<
   GetRecentlyAddedLibraryUnauthorized,
@@ -241,6 +265,26 @@ export namespace GetRecentlyAddedLibraryErrors$ {
   export type Outbound = GetRecentlyAddedLibraryErrors$Outbound;
 }
 
+export function getRecentlyAddedLibraryErrorsToJSON(
+  getRecentlyAddedLibraryErrors: GetRecentlyAddedLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetRecentlyAddedLibraryErrors$outboundSchema.parse(
+      getRecentlyAddedLibraryErrors,
+    ),
+  );
+}
+
+export function getRecentlyAddedLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetRecentlyAddedLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetRecentlyAddedLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetRecentlyAddedLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetRecentlyAddedLibraryBadRequest$inboundSchema: z.ZodType<
   GetRecentlyAddedLibraryBadRequest,

src/sdk/models/errors/getrefreshlibrarymetadata.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetRefreshLibraryMetadataLibraryErrors = {
   code?: number | undefined;
@@ -137,6 +140,28 @@ export namespace GetRefreshLibraryMetadataLibraryErrors$ {
   export type Outbound = GetRefreshLibraryMetadataLibraryErrors$Outbound;
 }
 
+export function getRefreshLibraryMetadataLibraryErrorsToJSON(
+  getRefreshLibraryMetadataLibraryErrors:
+    GetRefreshLibraryMetadataLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetRefreshLibraryMetadataLibraryErrors$outboundSchema.parse(
+      getRefreshLibraryMetadataLibraryErrors,
+    ),
+  );
+}
+
+export function getRefreshLibraryMetadataLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetRefreshLibraryMetadataLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetRefreshLibraryMetadataLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetRefreshLibraryMetadataLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetRefreshLibraryMetadataUnauthorized$inboundSchema: z.ZodType<
   GetRefreshLibraryMetadataUnauthorized,
@@ -241,6 +266,26 @@ export namespace GetRefreshLibraryMetadataErrors$ {
   export type Outbound = GetRefreshLibraryMetadataErrors$Outbound;
 }
 
+export function getRefreshLibraryMetadataErrorsToJSON(
+  getRefreshLibraryMetadataErrors: GetRefreshLibraryMetadataErrors,
+): string {
+  return JSON.stringify(
+    GetRefreshLibraryMetadataErrors$outboundSchema.parse(
+      getRefreshLibraryMetadataErrors,
+    ),
+  );
+}
+
+export function getRefreshLibraryMetadataErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetRefreshLibraryMetadataErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetRefreshLibraryMetadataErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetRefreshLibraryMetadataErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetRefreshLibraryMetadataBadRequest$inboundSchema: z.ZodType<
   GetRefreshLibraryMetadataBadRequest,

src/sdk/models/errors/getresizedphoto.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetResizedPhotoServerErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetResizedPhotoServerErrors$ {
   export type Outbound = GetResizedPhotoServerErrors$Outbound;
 }
 
+export function getResizedPhotoServerErrorsToJSON(
+  getResizedPhotoServerErrors: GetResizedPhotoServerErrors,
+): string {
+  return JSON.stringify(
+    GetResizedPhotoServerErrors$outboundSchema.parse(
+      getResizedPhotoServerErrors,
+    ),
+  );
+}
+
+export function getResizedPhotoServerErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetResizedPhotoServerErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetResizedPhotoServerErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetResizedPhotoServerErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetResizedPhotoUnauthorized$inboundSchema: z.ZodType<
   GetResizedPhotoUnauthorized,
@@ -235,6 +258,24 @@ export namespace GetResizedPhotoErrors$ {
   export type Outbound = GetResizedPhotoErrors$Outbound;
 }
 
+export function getResizedPhotoErrorsToJSON(
+  getResizedPhotoErrors: GetResizedPhotoErrors,
+): string {
+  return JSON.stringify(
+    GetResizedPhotoErrors$outboundSchema.parse(getResizedPhotoErrors),
+  );
+}
+
+export function getResizedPhotoErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetResizedPhotoErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetResizedPhotoErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetResizedPhotoErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetResizedPhotoBadRequest$inboundSchema: z.ZodType<
   GetResizedPhotoBadRequest,

src/sdk/models/errors/getresourcesstatistics.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetResourcesStatisticsStatisticsErrors = {
   code?: number | undefined;
@@ -137,6 +140,28 @@ export namespace GetResourcesStatisticsStatisticsErrors$ {
   export type Outbound = GetResourcesStatisticsStatisticsErrors$Outbound;
 }
 
+export function getResourcesStatisticsStatisticsErrorsToJSON(
+  getResourcesStatisticsStatisticsErrors:
+    GetResourcesStatisticsStatisticsErrors,
+): string {
+  return JSON.stringify(
+    GetResourcesStatisticsStatisticsErrors$outboundSchema.parse(
+      getResourcesStatisticsStatisticsErrors,
+    ),
+  );
+}
+
+export function getResourcesStatisticsStatisticsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetResourcesStatisticsStatisticsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetResourcesStatisticsStatisticsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetResourcesStatisticsStatisticsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetResourcesStatisticsUnauthorized$inboundSchema: z.ZodType<
   GetResourcesStatisticsUnauthorized,
@@ -240,6 +265,26 @@ export namespace GetResourcesStatisticsErrors$ {
   export type Outbound = GetResourcesStatisticsErrors$Outbound;
 }
 
+export function getResourcesStatisticsErrorsToJSON(
+  getResourcesStatisticsErrors: GetResourcesStatisticsErrors,
+): string {
+  return JSON.stringify(
+    GetResourcesStatisticsErrors$outboundSchema.parse(
+      getResourcesStatisticsErrors,
+    ),
+  );
+}
+
+export function getResourcesStatisticsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetResourcesStatisticsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetResourcesStatisticsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetResourcesStatisticsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetResourcesStatisticsBadRequest$inboundSchema: z.ZodType<
   GetResourcesStatisticsBadRequest,

src/sdk/models/errors/getsearchalllibraries.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetSearchAllLibrariesLibraryErrors = {
   code?: number | undefined;
@@ -136,6 +139,27 @@ export namespace GetSearchAllLibrariesLibraryErrors$ {
   export type Outbound = GetSearchAllLibrariesLibraryErrors$Outbound;
 }
 
+export function getSearchAllLibrariesLibraryErrorsToJSON(
+  getSearchAllLibrariesLibraryErrors: GetSearchAllLibrariesLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetSearchAllLibrariesLibraryErrors$outboundSchema.parse(
+      getSearchAllLibrariesLibraryErrors,
+    ),
+  );
+}
+
+export function getSearchAllLibrariesLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSearchAllLibrariesLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetSearchAllLibrariesLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSearchAllLibrariesLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetSearchAllLibrariesUnauthorized$inboundSchema: z.ZodType<
   GetSearchAllLibrariesUnauthorized,
@@ -239,6 +263,26 @@ export namespace GetSearchAllLibrariesErrors$ {
   export type Outbound = GetSearchAllLibrariesErrors$Outbound;
 }
 
+export function getSearchAllLibrariesErrorsToJSON(
+  getSearchAllLibrariesErrors: GetSearchAllLibrariesErrors,
+): string {
+  return JSON.stringify(
+    GetSearchAllLibrariesErrors$outboundSchema.parse(
+      getSearchAllLibrariesErrors,
+    ),
+  );
+}
+
+export function getSearchAllLibrariesErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSearchAllLibrariesErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetSearchAllLibrariesErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSearchAllLibrariesErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetSearchAllLibrariesBadRequest$inboundSchema: z.ZodType<
   GetSearchAllLibrariesBadRequest,

src/sdk/models/errors/getsearchlibrary.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetSearchLibraryLibraryErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetSearchLibraryLibraryErrors$ {
   export type Outbound = GetSearchLibraryLibraryErrors$Outbound;
 }
 
+export function getSearchLibraryLibraryErrorsToJSON(
+  getSearchLibraryLibraryErrors: GetSearchLibraryLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetSearchLibraryLibraryErrors$outboundSchema.parse(
+      getSearchLibraryLibraryErrors,
+    ),
+  );
+}
+
+export function getSearchLibraryLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSearchLibraryLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetSearchLibraryLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSearchLibraryLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetSearchLibraryUnauthorized$inboundSchema: z.ZodType<
   GetSearchLibraryUnauthorized,
@@ -236,6 +259,24 @@ export namespace GetSearchLibraryErrors$ {
   export type Outbound = GetSearchLibraryErrors$Outbound;
 }
 
+export function getSearchLibraryErrorsToJSON(
+  getSearchLibraryErrors: GetSearchLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetSearchLibraryErrors$outboundSchema.parse(getSearchLibraryErrors),
+  );
+}
+
+export function getSearchLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSearchLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetSearchLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSearchLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetSearchLibraryBadRequest$inboundSchema: z.ZodType<
   GetSearchLibraryBadRequest,

src/sdk/models/errors/getsearchresults.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetSearchResultsSearchErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetSearchResultsSearchErrors$ {
   export type Outbound = GetSearchResultsSearchErrors$Outbound;
 }
 
+export function getSearchResultsSearchErrorsToJSON(
+  getSearchResultsSearchErrors: GetSearchResultsSearchErrors,
+): string {
+  return JSON.stringify(
+    GetSearchResultsSearchErrors$outboundSchema.parse(
+      getSearchResultsSearchErrors,
+    ),
+  );
+}
+
+export function getSearchResultsSearchErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSearchResultsSearchErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetSearchResultsSearchErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSearchResultsSearchErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetSearchResultsUnauthorized$inboundSchema: z.ZodType<
   GetSearchResultsUnauthorized,
@@ -235,6 +258,24 @@ export namespace GetSearchResultsErrors$ {
   export type Outbound = GetSearchResultsErrors$Outbound;
 }
 
+export function getSearchResultsErrorsToJSON(
+  getSearchResultsErrors: GetSearchResultsErrors,
+): string {
+  return JSON.stringify(
+    GetSearchResultsErrors$outboundSchema.parse(getSearchResultsErrors),
+  );
+}
+
+export function getSearchResultsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSearchResultsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetSearchResultsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSearchResultsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetSearchResultsBadRequest$inboundSchema: z.ZodType<
   GetSearchResultsBadRequest,

src/sdk/models/errors/getserveractivities.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetServerActivitiesActivitiesErrors = {
   code?: number | undefined;
@@ -137,6 +140,27 @@ export namespace GetServerActivitiesActivitiesErrors$ {
   export type Outbound = GetServerActivitiesActivitiesErrors$Outbound;
 }
 
+export function getServerActivitiesActivitiesErrorsToJSON(
+  getServerActivitiesActivitiesErrors: GetServerActivitiesActivitiesErrors,
+): string {
+  return JSON.stringify(
+    GetServerActivitiesActivitiesErrors$outboundSchema.parse(
+      getServerActivitiesActivitiesErrors,
+    ),
+  );
+}
+
+export function getServerActivitiesActivitiesErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetServerActivitiesActivitiesErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetServerActivitiesActivitiesErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetServerActivitiesActivitiesErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetServerActivitiesUnauthorized$inboundSchema: z.ZodType<
   GetServerActivitiesUnauthorized,
@@ -239,6 +263,24 @@ export namespace GetServerActivitiesErrors$ {
   export type Outbound = GetServerActivitiesErrors$Outbound;
 }
 
+export function getServerActivitiesErrorsToJSON(
+  getServerActivitiesErrors: GetServerActivitiesErrors,
+): string {
+  return JSON.stringify(
+    GetServerActivitiesErrors$outboundSchema.parse(getServerActivitiesErrors),
+  );
+}
+
+export function getServerActivitiesErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetServerActivitiesErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetServerActivitiesErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetServerActivitiesErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetServerActivitiesBadRequest$inboundSchema: z.ZodType<
   GetServerActivitiesBadRequest,

src/sdk/models/errors/getservercapabilities.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetServerCapabilitiesErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetServerCapabilitiesErrors$ {
   export type Outbound = GetServerCapabilitiesErrors$Outbound;
 }
 
+export function getServerCapabilitiesErrorsToJSON(
+  getServerCapabilitiesErrors: GetServerCapabilitiesErrors,
+): string {
+  return JSON.stringify(
+    GetServerCapabilitiesErrors$outboundSchema.parse(
+      getServerCapabilitiesErrors,
+    ),
+  );
+}
+
+export function getServerCapabilitiesErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetServerCapabilitiesErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetServerCapabilitiesErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetServerCapabilitiesErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetServerCapabilitiesUnauthorized$inboundSchema: z.ZodType<
   GetServerCapabilitiesUnauthorized,
@@ -233,6 +256,20 @@ export namespace Errors$ {
   export type Outbound = Errors$Outbound;
 }
 
+export function errorsToJSON(errors: Errors): string {
+  return JSON.stringify(Errors$outboundSchema.parse(errors));
+}
+
+export function errorsFromJSON(
+  jsonString: string,
+): SafeParseResult<Errors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Errors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Errors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetServerCapabilitiesBadRequest$inboundSchema: z.ZodType<
   GetServerCapabilitiesBadRequest,

src/sdk/models/errors/getserverlist.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetServerListServerErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetServerListServerErrors$ {
   export type Outbound = GetServerListServerErrors$Outbound;
 }
 
+export function getServerListServerErrorsToJSON(
+  getServerListServerErrors: GetServerListServerErrors,
+): string {
+  return JSON.stringify(
+    GetServerListServerErrors$outboundSchema.parse(getServerListServerErrors),
+  );
+}
+
+export function getServerListServerErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetServerListServerErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetServerListServerErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetServerListServerErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetServerListUnauthorized$inboundSchema: z.ZodType<
   GetServerListUnauthorized,
@@ -235,6 +256,24 @@ export namespace GetServerListErrors$ {
   export type Outbound = GetServerListErrors$Outbound;
 }
 
+export function getServerListErrorsToJSON(
+  getServerListErrors: GetServerListErrors,
+): string {
+  return JSON.stringify(
+    GetServerListErrors$outboundSchema.parse(getServerListErrors),
+  );
+}
+
+export function getServerListErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetServerListErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetServerListErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetServerListErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetServerListBadRequest$inboundSchema: z.ZodType<
   GetServerListBadRequest,

src/sdk/models/errors/getserverpreferences.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetServerPreferencesServerErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetServerPreferencesServerErrors$ {
   export type Outbound = GetServerPreferencesServerErrors$Outbound;
 }
 
+export function getServerPreferencesServerErrorsToJSON(
+  getServerPreferencesServerErrors: GetServerPreferencesServerErrors,
+): string {
+  return JSON.stringify(
+    GetServerPreferencesServerErrors$outboundSchema.parse(
+      getServerPreferencesServerErrors,
+    ),
+  );
+}
+
+export function getServerPreferencesServerErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetServerPreferencesServerErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetServerPreferencesServerErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetServerPreferencesServerErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetServerPreferencesUnauthorized$inboundSchema: z.ZodType<
   GetServerPreferencesUnauthorized,
@@ -236,6 +259,24 @@ export namespace GetServerPreferencesErrors$ {
   export type Outbound = GetServerPreferencesErrors$Outbound;
 }
 
+export function getServerPreferencesErrorsToJSON(
+  getServerPreferencesErrors: GetServerPreferencesErrors,
+): string {
+  return JSON.stringify(
+    GetServerPreferencesErrors$outboundSchema.parse(getServerPreferencesErrors),
+  );
+}
+
+export function getServerPreferencesErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetServerPreferencesErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetServerPreferencesErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetServerPreferencesErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetServerPreferencesBadRequest$inboundSchema: z.ZodType<
   GetServerPreferencesBadRequest,

src/sdk/models/errors/getserverresources.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetServerResourcesPlexErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetServerResourcesPlexErrors$ {
   export type Outbound = GetServerResourcesPlexErrors$Outbound;
 }
 
+export function getServerResourcesPlexErrorsToJSON(
+  getServerResourcesPlexErrors: GetServerResourcesPlexErrors,
+): string {
+  return JSON.stringify(
+    GetServerResourcesPlexErrors$outboundSchema.parse(
+      getServerResourcesPlexErrors,
+    ),
+  );
+}
+
+export function getServerResourcesPlexErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetServerResourcesPlexErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetServerResourcesPlexErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetServerResourcesPlexErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetServerResourcesUnauthorized$inboundSchema: z.ZodType<
   GetServerResourcesUnauthorized,
@@ -235,6 +258,24 @@ export namespace GetServerResourcesErrors$ {
   export type Outbound = GetServerResourcesErrors$Outbound;
 }
 
+export function getServerResourcesErrorsToJSON(
+  getServerResourcesErrors: GetServerResourcesErrors,
+): string {
+  return JSON.stringify(
+    GetServerResourcesErrors$outboundSchema.parse(getServerResourcesErrors),
+  );
+}
+
+export function getServerResourcesErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetServerResourcesErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetServerResourcesErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetServerResourcesErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetServerResourcesBadRequest$inboundSchema: z.ZodType<
   GetServerResourcesBadRequest,

src/sdk/models/errors/getsessionhistory.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetSessionHistorySessionsErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetSessionHistorySessionsErrors$ {
   export type Outbound = GetSessionHistorySessionsErrors$Outbound;
 }
 
+export function getSessionHistorySessionsErrorsToJSON(
+  getSessionHistorySessionsErrors: GetSessionHistorySessionsErrors,
+): string {
+  return JSON.stringify(
+    GetSessionHistorySessionsErrors$outboundSchema.parse(
+      getSessionHistorySessionsErrors,
+    ),
+  );
+}
+
+export function getSessionHistorySessionsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSessionHistorySessionsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetSessionHistorySessionsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSessionHistorySessionsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetSessionHistoryUnauthorized$inboundSchema: z.ZodType<
   GetSessionHistoryUnauthorized,
@@ -236,6 +259,24 @@ export namespace GetSessionHistoryErrors$ {
   export type Outbound = GetSessionHistoryErrors$Outbound;
 }
 
+export function getSessionHistoryErrorsToJSON(
+  getSessionHistoryErrors: GetSessionHistoryErrors,
+): string {
+  return JSON.stringify(
+    GetSessionHistoryErrors$outboundSchema.parse(getSessionHistoryErrors),
+  );
+}
+
+export function getSessionHistoryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSessionHistoryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetSessionHistoryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSessionHistoryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetSessionHistoryBadRequest$inboundSchema: z.ZodType<
   GetSessionHistoryBadRequest,

src/sdk/models/errors/getsessions.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetSessionsSessionsErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetSessionsSessionsErrors$ {
   export type Outbound = GetSessionsSessionsErrors$Outbound;
 }
 
+export function getSessionsSessionsErrorsToJSON(
+  getSessionsSessionsErrors: GetSessionsSessionsErrors,
+): string {
+  return JSON.stringify(
+    GetSessionsSessionsErrors$outboundSchema.parse(getSessionsSessionsErrors),
+  );
+}
+
+export function getSessionsSessionsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSessionsSessionsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetSessionsSessionsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSessionsSessionsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetSessionsUnauthorized$inboundSchema: z.ZodType<
   GetSessionsUnauthorized,
@@ -235,6 +256,24 @@ export namespace GetSessionsErrors$ {
   export type Outbound = GetSessionsErrors$Outbound;
 }
 
+export function getSessionsErrorsToJSON(
+  getSessionsErrors: GetSessionsErrors,
+): string {
+  return JSON.stringify(
+    GetSessionsErrors$outboundSchema.parse(getSessionsErrors),
+  );
+}
+
+export function getSessionsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSessionsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetSessionsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSessionsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetSessionsBadRequest$inboundSchema: z.ZodType<
   GetSessionsBadRequest,

src/sdk/models/errors/getsourceconnectioninformation.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetSourceConnectionInformationAuthenticationErrors = {
   code?: number | undefined;
@@ -144,6 +147,33 @@ export namespace GetSourceConnectionInformationAuthenticationErrors$ {
     GetSourceConnectionInformationAuthenticationErrors$Outbound;
 }
 
+export function getSourceConnectionInformationAuthenticationErrorsToJSON(
+  getSourceConnectionInformationAuthenticationErrors:
+    GetSourceConnectionInformationAuthenticationErrors,
+): string {
+  return JSON.stringify(
+    GetSourceConnectionInformationAuthenticationErrors$outboundSchema.parse(
+      getSourceConnectionInformationAuthenticationErrors,
+    ),
+  );
+}
+
+export function getSourceConnectionInformationAuthenticationErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetSourceConnectionInformationAuthenticationErrors,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetSourceConnectionInformationAuthenticationErrors$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetSourceConnectionInformationAuthenticationErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetSourceConnectionInformationUnauthorized$inboundSchema:
   z.ZodType<GetSourceConnectionInformationUnauthorized, z.ZodTypeDef, unknown> =
@@ -253,6 +283,27 @@ export namespace GetSourceConnectionInformationErrors$ {
   export type Outbound = GetSourceConnectionInformationErrors$Outbound;
 }
 
+export function getSourceConnectionInformationErrorsToJSON(
+  getSourceConnectionInformationErrors: GetSourceConnectionInformationErrors,
+): string {
+  return JSON.stringify(
+    GetSourceConnectionInformationErrors$outboundSchema.parse(
+      getSourceConnectionInformationErrors,
+    ),
+  );
+}
+
+export function getSourceConnectionInformationErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSourceConnectionInformationErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetSourceConnectionInformationErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSourceConnectionInformationErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetSourceConnectionInformationBadRequest$inboundSchema: z.ZodType<
   GetSourceConnectionInformationBadRequest,

src/sdk/models/errors/getstatistics.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetStatisticsStatisticsErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetStatisticsStatisticsErrors$ {
   export type Outbound = GetStatisticsStatisticsErrors$Outbound;
 }
 
+export function getStatisticsStatisticsErrorsToJSON(
+  getStatisticsStatisticsErrors: GetStatisticsStatisticsErrors,
+): string {
+  return JSON.stringify(
+    GetStatisticsStatisticsErrors$outboundSchema.parse(
+      getStatisticsStatisticsErrors,
+    ),
+  );
+}
+
+export function getStatisticsStatisticsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetStatisticsStatisticsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetStatisticsStatisticsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetStatisticsStatisticsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetStatisticsUnauthorized$inboundSchema: z.ZodType<
   GetStatisticsUnauthorized,
@@ -236,6 +259,24 @@ export namespace GetStatisticsErrors$ {
   export type Outbound = GetStatisticsErrors$Outbound;
 }
 
+export function getStatisticsErrorsToJSON(
+  getStatisticsErrors: GetStatisticsErrors,
+): string {
+  return JSON.stringify(
+    GetStatisticsErrors$outboundSchema.parse(getStatisticsErrors),
+  );
+}
+
+export function getStatisticsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetStatisticsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetStatisticsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetStatisticsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetStatisticsBadRequest$inboundSchema: z.ZodType<
   GetStatisticsBadRequest,

src/sdk/models/errors/getthumbimage.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetThumbImageMediaErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetThumbImageMediaErrors$ {
   export type Outbound = GetThumbImageMediaErrors$Outbound;
 }
 
+export function getThumbImageMediaErrorsToJSON(
+  getThumbImageMediaErrors: GetThumbImageMediaErrors,
+): string {
+  return JSON.stringify(
+    GetThumbImageMediaErrors$outboundSchema.parse(getThumbImageMediaErrors),
+  );
+}
+
+export function getThumbImageMediaErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetThumbImageMediaErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetThumbImageMediaErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetThumbImageMediaErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetThumbImageUnauthorized$inboundSchema: z.ZodType<
   GetThumbImageUnauthorized,
@@ -235,6 +256,24 @@ export namespace GetThumbImageErrors$ {
   export type Outbound = GetThumbImageErrors$Outbound;
 }
 
+export function getThumbImageErrorsToJSON(
+  getThumbImageErrors: GetThumbImageErrors,
+): string {
+  return JSON.stringify(
+    GetThumbImageErrors$outboundSchema.parse(getThumbImageErrors),
+  );
+}
+
+export function getThumbImageErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetThumbImageErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetThumbImageErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetThumbImageErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetThumbImageBadRequest$inboundSchema: z.ZodType<
   GetThumbImageBadRequest,

src/sdk/models/errors/gettimeline.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetTimelineVideoErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetTimelineVideoErrors$ {
   export type Outbound = GetTimelineVideoErrors$Outbound;
 }
 
+export function getTimelineVideoErrorsToJSON(
+  getTimelineVideoErrors: GetTimelineVideoErrors,
+): string {
+  return JSON.stringify(
+    GetTimelineVideoErrors$outboundSchema.parse(getTimelineVideoErrors),
+  );
+}
+
+export function getTimelineVideoErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetTimelineVideoErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetTimelineVideoErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetTimelineVideoErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetTimelineUnauthorized$inboundSchema: z.ZodType<
   GetTimelineUnauthorized,
@@ -235,6 +256,24 @@ export namespace GetTimelineErrors$ {
   export type Outbound = GetTimelineErrors$Outbound;
 }
 
+export function getTimelineErrorsToJSON(
+  getTimelineErrors: GetTimelineErrors,
+): string {
+  return JSON.stringify(
+    GetTimelineErrors$outboundSchema.parse(getTimelineErrors),
+  );
+}
+
+export function getTimelineErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetTimelineErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetTimelineErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetTimelineErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetTimelineBadRequest$inboundSchema: z.ZodType<
   GetTimelineBadRequest,

src/sdk/models/errors/gettokenbypinid.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetTokenByPinIdPlexErrors = {
   code?: number | undefined;
@@ -131,6 +134,24 @@ export namespace GetTokenByPinIdPlexErrors$ {
   export type Outbound = GetTokenByPinIdPlexErrors$Outbound;
 }
 
+export function getTokenByPinIdPlexErrorsToJSON(
+  getTokenByPinIdPlexErrors: GetTokenByPinIdPlexErrors,
+): string {
+  return JSON.stringify(
+    GetTokenByPinIdPlexErrors$outboundSchema.parse(getTokenByPinIdPlexErrors),
+  );
+}
+
+export function getTokenByPinIdPlexErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetTokenByPinIdPlexErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetTokenByPinIdPlexErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetTokenByPinIdPlexErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetTokenByPinIdResponseBody$inboundSchema: z.ZodType<
   GetTokenByPinIdResponseBody,
@@ -231,6 +252,24 @@ export namespace GetTokenByPinIdErrors$ {
   export type Outbound = GetTokenByPinIdErrors$Outbound;
 }
 
+export function getTokenByPinIdErrorsToJSON(
+  getTokenByPinIdErrors: GetTokenByPinIdErrors,
+): string {
+  return JSON.stringify(
+    GetTokenByPinIdErrors$outboundSchema.parse(getTokenByPinIdErrors),
+  );
+}
+
+export function getTokenByPinIdErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetTokenByPinIdErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetTokenByPinIdErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetTokenByPinIdErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetTokenByPinIdBadRequest$inboundSchema: z.ZodType<
   GetTokenByPinIdBadRequest,

src/sdk/models/errors/gettokendetails.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetTokenDetailsAuthenticationErrors = {
   code?: number | undefined;
@@ -137,6 +140,27 @@ export namespace GetTokenDetailsAuthenticationErrors$ {
   export type Outbound = GetTokenDetailsAuthenticationErrors$Outbound;
 }
 
+export function getTokenDetailsAuthenticationErrorsToJSON(
+  getTokenDetailsAuthenticationErrors: GetTokenDetailsAuthenticationErrors,
+): string {
+  return JSON.stringify(
+    GetTokenDetailsAuthenticationErrors$outboundSchema.parse(
+      getTokenDetailsAuthenticationErrors,
+    ),
+  );
+}
+
+export function getTokenDetailsAuthenticationErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetTokenDetailsAuthenticationErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetTokenDetailsAuthenticationErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetTokenDetailsAuthenticationErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetTokenDetailsUnauthorized$inboundSchema: z.ZodType<
   GetTokenDetailsUnauthorized,
@@ -239,6 +263,24 @@ export namespace GetTokenDetailsErrors$ {
   export type Outbound = GetTokenDetailsErrors$Outbound;
 }
 
+export function getTokenDetailsErrorsToJSON(
+  getTokenDetailsErrors: GetTokenDetailsErrors,
+): string {
+  return JSON.stringify(
+    GetTokenDetailsErrors$outboundSchema.parse(getTokenDetailsErrors),
+  );
+}
+
+export function getTokenDetailsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetTokenDetailsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetTokenDetailsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetTokenDetailsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetTokenDetailsBadRequest$inboundSchema: z.ZodType<
   GetTokenDetailsBadRequest,

src/sdk/models/errors/gettopwatchedcontent.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetTopWatchedContentLibraryErrors = {
   code?: number | undefined;
@@ -136,6 +139,26 @@ export namespace GetTopWatchedContentLibraryErrors$ {
   export type Outbound = GetTopWatchedContentLibraryErrors$Outbound;
 }
 
+export function getTopWatchedContentLibraryErrorsToJSON(
+  getTopWatchedContentLibraryErrors: GetTopWatchedContentLibraryErrors,
+): string {
+  return JSON.stringify(
+    GetTopWatchedContentLibraryErrors$outboundSchema.parse(
+      getTopWatchedContentLibraryErrors,
+    ),
+  );
+}
+
+export function getTopWatchedContentLibraryErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetTopWatchedContentLibraryErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetTopWatchedContentLibraryErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetTopWatchedContentLibraryErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetTopWatchedContentUnauthorized$inboundSchema: z.ZodType<
   GetTopWatchedContentUnauthorized,
@@ -237,6 +260,24 @@ export namespace GetTopWatchedContentErrors$ {
   export type Outbound = GetTopWatchedContentErrors$Outbound;
 }
 
+export function getTopWatchedContentErrorsToJSON(
+  getTopWatchedContentErrors: GetTopWatchedContentErrors,
+): string {
+  return JSON.stringify(
+    GetTopWatchedContentErrors$outboundSchema.parse(getTopWatchedContentErrors),
+  );
+}
+
+export function getTopWatchedContentErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetTopWatchedContentErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetTopWatchedContentErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetTopWatchedContentErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetTopWatchedContentBadRequest$inboundSchema: z.ZodType<
   GetTopWatchedContentBadRequest,

src/sdk/models/errors/gettranscodesessions.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetTranscodeSessionsSessionsErrors = {
   code?: number | undefined;
@@ -136,6 +139,27 @@ export namespace GetTranscodeSessionsSessionsErrors$ {
   export type Outbound = GetTranscodeSessionsSessionsErrors$Outbound;
 }
 
+export function getTranscodeSessionsSessionsErrorsToJSON(
+  getTranscodeSessionsSessionsErrors: GetTranscodeSessionsSessionsErrors,
+): string {
+  return JSON.stringify(
+    GetTranscodeSessionsSessionsErrors$outboundSchema.parse(
+      getTranscodeSessionsSessionsErrors,
+    ),
+  );
+}
+
+export function getTranscodeSessionsSessionsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetTranscodeSessionsSessionsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetTranscodeSessionsSessionsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetTranscodeSessionsSessionsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetTranscodeSessionsUnauthorized$inboundSchema: z.ZodType<
   GetTranscodeSessionsUnauthorized,
@@ -238,6 +262,24 @@ export namespace GetTranscodeSessionsErrors$ {
   export type Outbound = GetTranscodeSessionsErrors$Outbound;
 }
 
+export function getTranscodeSessionsErrorsToJSON(
+  getTranscodeSessionsErrors: GetTranscodeSessionsErrors,
+): string {
+  return JSON.stringify(
+    GetTranscodeSessionsErrors$outboundSchema.parse(getTranscodeSessionsErrors),
+  );
+}
+
+export function getTranscodeSessionsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetTranscodeSessionsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetTranscodeSessionsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetTranscodeSessionsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetTranscodeSessionsBadRequest$inboundSchema: z.ZodType<
   GetTranscodeSessionsBadRequest,

src/sdk/models/errors/gettransienttoken.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetTransientTokenAuthenticationErrors = {
   code?: number | undefined;
@@ -137,6 +140,27 @@ export namespace GetTransientTokenAuthenticationErrors$ {
   export type Outbound = GetTransientTokenAuthenticationErrors$Outbound;
 }
 
+export function getTransientTokenAuthenticationErrorsToJSON(
+  getTransientTokenAuthenticationErrors: GetTransientTokenAuthenticationErrors,
+): string {
+  return JSON.stringify(
+    GetTransientTokenAuthenticationErrors$outboundSchema.parse(
+      getTransientTokenAuthenticationErrors,
+    ),
+  );
+}
+
+export function getTransientTokenAuthenticationErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetTransientTokenAuthenticationErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetTransientTokenAuthenticationErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetTransientTokenAuthenticationErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetTransientTokenUnauthorized$inboundSchema: z.ZodType<
   GetTransientTokenUnauthorized,
@@ -239,6 +263,24 @@ export namespace GetTransientTokenErrors$ {
   export type Outbound = GetTransientTokenErrors$Outbound;
 }
 
+export function getTransientTokenErrorsToJSON(
+  getTransientTokenErrors: GetTransientTokenErrors,
+): string {
+  return JSON.stringify(
+    GetTransientTokenErrors$outboundSchema.parse(getTransientTokenErrors),
+  );
+}
+
+export function getTransientTokenErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetTransientTokenErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetTransientTokenErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetTransientTokenErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetTransientTokenBadRequest$inboundSchema: z.ZodType<
   GetTransientTokenBadRequest,

src/sdk/models/errors/getupdatestatus.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetUpdateStatusUpdaterErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetUpdateStatusUpdaterErrors$ {
   export type Outbound = GetUpdateStatusUpdaterErrors$Outbound;
 }
 
+export function getUpdateStatusUpdaterErrorsToJSON(
+  getUpdateStatusUpdaterErrors: GetUpdateStatusUpdaterErrors,
+): string {
+  return JSON.stringify(
+    GetUpdateStatusUpdaterErrors$outboundSchema.parse(
+      getUpdateStatusUpdaterErrors,
+    ),
+  );
+}
+
+export function getUpdateStatusUpdaterErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetUpdateStatusUpdaterErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetUpdateStatusUpdaterErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetUpdateStatusUpdaterErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetUpdateStatusUnauthorized$inboundSchema: z.ZodType<
   GetUpdateStatusUnauthorized,
@@ -235,6 +258,24 @@ export namespace GetUpdateStatusErrors$ {
   export type Outbound = GetUpdateStatusErrors$Outbound;
 }
 
+export function getUpdateStatusErrorsToJSON(
+  getUpdateStatusErrors: GetUpdateStatusErrors,
+): string {
+  return JSON.stringify(
+    GetUpdateStatusErrors$outboundSchema.parse(getUpdateStatusErrors),
+  );
+}
+
+export function getUpdateStatusErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetUpdateStatusErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetUpdateStatusErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetUpdateStatusErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetUpdateStatusBadRequest$inboundSchema: z.ZodType<
   GetUpdateStatusBadRequest,

src/sdk/models/errors/getuserfriends.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetUserFriendsPlexErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace GetUserFriendsPlexErrors$ {
   export type Outbound = GetUserFriendsPlexErrors$Outbound;
 }
 
+export function getUserFriendsPlexErrorsToJSON(
+  getUserFriendsPlexErrors: GetUserFriendsPlexErrors,
+): string {
+  return JSON.stringify(
+    GetUserFriendsPlexErrors$outboundSchema.parse(getUserFriendsPlexErrors),
+  );
+}
+
+export function getUserFriendsPlexErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetUserFriendsPlexErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetUserFriendsPlexErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetUserFriendsPlexErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetUserFriendsUnauthorized$inboundSchema: z.ZodType<
   GetUserFriendsUnauthorized,
@@ -235,6 +256,24 @@ export namespace GetUserFriendsErrors$ {
   export type Outbound = GetUserFriendsErrors$Outbound;
 }
 
+export function getUserFriendsErrorsToJSON(
+  getUserFriendsErrors: GetUserFriendsErrors,
+): string {
+  return JSON.stringify(
+    GetUserFriendsErrors$outboundSchema.parse(getUserFriendsErrors),
+  );
+}
+
+export function getUserFriendsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetUserFriendsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetUserFriendsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetUserFriendsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetUserFriendsBadRequest$inboundSchema: z.ZodType<
   GetUserFriendsBadRequest,

src/sdk/models/errors/getwatchlist.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type GetWatchListWatchlistErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace GetWatchListWatchlistErrors$ {
   export type Outbound = GetWatchListWatchlistErrors$Outbound;
 }
 
+export function getWatchListWatchlistErrorsToJSON(
+  getWatchListWatchlistErrors: GetWatchListWatchlistErrors,
+): string {
+  return JSON.stringify(
+    GetWatchListWatchlistErrors$outboundSchema.parse(
+      getWatchListWatchlistErrors,
+    ),
+  );
+}
+
+export function getWatchListWatchlistErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetWatchListWatchlistErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetWatchListWatchlistErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetWatchListWatchlistErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetWatchListUnauthorized$inboundSchema: z.ZodType<
   GetWatchListUnauthorized,
@@ -235,6 +258,24 @@ export namespace GetWatchListErrors$ {
   export type Outbound = GetWatchListErrors$Outbound;
 }
 
+export function getWatchListErrorsToJSON(
+  getWatchListErrors: GetWatchListErrors,
+): string {
+  return JSON.stringify(
+    GetWatchListErrors$outboundSchema.parse(getWatchListErrors),
+  );
+}
+
+export function getWatchListErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetWatchListErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetWatchListErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetWatchListErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetWatchListBadRequest$inboundSchema: z.ZodType<
   GetWatchListBadRequest,

src/sdk/models/errors/logline.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type LogLineLogErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace LogLineLogErrors$ {
   export type Outbound = LogLineLogErrors$Outbound;
 }
 
+export function logLineLogErrorsToJSON(
+  logLineLogErrors: LogLineLogErrors,
+): string {
+  return JSON.stringify(
+    LogLineLogErrors$outboundSchema.parse(logLineLogErrors),
+  );
+}
+
+export function logLineLogErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<LogLineLogErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LogLineLogErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LogLineLogErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const LogLineUnauthorized$inboundSchema: z.ZodType<
   LogLineUnauthorized,
@@ -233,6 +254,20 @@ export namespace LogLineErrors$ {
   export type Outbound = LogLineErrors$Outbound;
 }
 
+export function logLineErrorsToJSON(logLineErrors: LogLineErrors): string {
+  return JSON.stringify(LogLineErrors$outboundSchema.parse(logLineErrors));
+}
+
+export function logLineErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<LogLineErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LogLineErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LogLineErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const LogLineBadRequest$inboundSchema: z.ZodType<
   LogLineBadRequest,

src/sdk/models/errors/logmultiline.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type LogMultiLineLogErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace LogMultiLineLogErrors$ {
   export type Outbound = LogMultiLineLogErrors$Outbound;
 }
 
+export function logMultiLineLogErrorsToJSON(
+  logMultiLineLogErrors: LogMultiLineLogErrors,
+): string {
+  return JSON.stringify(
+    LogMultiLineLogErrors$outboundSchema.parse(logMultiLineLogErrors),
+  );
+}
+
+export function logMultiLineLogErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<LogMultiLineLogErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LogMultiLineLogErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LogMultiLineLogErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const LogMultiLineUnauthorized$inboundSchema: z.ZodType<
   LogMultiLineUnauthorized,
@@ -234,6 +255,24 @@ export namespace LogMultiLineErrors$ {
   export type Outbound = LogMultiLineErrors$Outbound;
 }
 
+export function logMultiLineErrorsToJSON(
+  logMultiLineErrors: LogMultiLineErrors,
+): string {
+  return JSON.stringify(
+    LogMultiLineErrors$outboundSchema.parse(logMultiLineErrors),
+  );
+}
+
+export function logMultiLineErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<LogMultiLineErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LogMultiLineErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LogMultiLineErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const LogMultiLineBadRequest$inboundSchema: z.ZodType<
   LogMultiLineBadRequest,

src/sdk/models/errors/markplayed.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type MarkPlayedMediaErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace MarkPlayedMediaErrors$ {
   export type Outbound = MarkPlayedMediaErrors$Outbound;
 }
 
+export function markPlayedMediaErrorsToJSON(
+  markPlayedMediaErrors: MarkPlayedMediaErrors,
+): string {
+  return JSON.stringify(
+    MarkPlayedMediaErrors$outboundSchema.parse(markPlayedMediaErrors),
+  );
+}
+
+export function markPlayedMediaErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<MarkPlayedMediaErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MarkPlayedMediaErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MarkPlayedMediaErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const MarkPlayedUnauthorized$inboundSchema: z.ZodType<
   MarkPlayedUnauthorized,
@@ -234,6 +255,24 @@ export namespace MarkPlayedErrors$ {
   export type Outbound = MarkPlayedErrors$Outbound;
 }
 
+export function markPlayedErrorsToJSON(
+  markPlayedErrors: MarkPlayedErrors,
+): string {
+  return JSON.stringify(
+    MarkPlayedErrors$outboundSchema.parse(markPlayedErrors),
+  );
+}
+
+export function markPlayedErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<MarkPlayedErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MarkPlayedErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MarkPlayedErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const MarkPlayedBadRequest$inboundSchema: z.ZodType<
   MarkPlayedBadRequest,

src/sdk/models/errors/markunplayed.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type MarkUnplayedMediaErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace MarkUnplayedMediaErrors$ {
   export type Outbound = MarkUnplayedMediaErrors$Outbound;
 }
 
+export function markUnplayedMediaErrorsToJSON(
+  markUnplayedMediaErrors: MarkUnplayedMediaErrors,
+): string {
+  return JSON.stringify(
+    MarkUnplayedMediaErrors$outboundSchema.parse(markUnplayedMediaErrors),
+  );
+}
+
+export function markUnplayedMediaErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<MarkUnplayedMediaErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MarkUnplayedMediaErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MarkUnplayedMediaErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const MarkUnplayedUnauthorized$inboundSchema: z.ZodType<
   MarkUnplayedUnauthorized,
@@ -235,6 +256,24 @@ export namespace MarkUnplayedErrors$ {
   export type Outbound = MarkUnplayedErrors$Outbound;
 }
 
+export function markUnplayedErrorsToJSON(
+  markUnplayedErrors: MarkUnplayedErrors,
+): string {
+  return JSON.stringify(
+    MarkUnplayedErrors$outboundSchema.parse(markUnplayedErrors),
+  );
+}
+
+export function markUnplayedErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<MarkUnplayedErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MarkUnplayedErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MarkUnplayedErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const MarkUnplayedBadRequest$inboundSchema: z.ZodType<
   MarkUnplayedBadRequest,

src/sdk/models/errors/performsearch.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type PerformSearchSearchErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace PerformSearchSearchErrors$ {
   export type Outbound = PerformSearchSearchErrors$Outbound;
 }
 
+export function performSearchSearchErrorsToJSON(
+  performSearchSearchErrors: PerformSearchSearchErrors,
+): string {
+  return JSON.stringify(
+    PerformSearchSearchErrors$outboundSchema.parse(performSearchSearchErrors),
+  );
+}
+
+export function performSearchSearchErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<PerformSearchSearchErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PerformSearchSearchErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PerformSearchSearchErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const PerformSearchUnauthorized$inboundSchema: z.ZodType<
   PerformSearchUnauthorized,
@@ -235,6 +256,24 @@ export namespace PerformSearchErrors$ {
   export type Outbound = PerformSearchErrors$Outbound;
 }
 
+export function performSearchErrorsToJSON(
+  performSearchErrors: PerformSearchErrors,
+): string {
+  return JSON.stringify(
+    PerformSearchErrors$outboundSchema.parse(performSearchErrors),
+  );
+}
+
+export function performSearchErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<PerformSearchErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PerformSearchErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PerformSearchErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const PerformSearchBadRequest$inboundSchema: z.ZodType<
   PerformSearchBadRequest,

src/sdk/models/errors/performvoicesearch.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type PerformVoiceSearchSearchErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace PerformVoiceSearchSearchErrors$ {
   export type Outbound = PerformVoiceSearchSearchErrors$Outbound;
 }
 
+export function performVoiceSearchSearchErrorsToJSON(
+  performVoiceSearchSearchErrors: PerformVoiceSearchSearchErrors,
+): string {
+  return JSON.stringify(
+    PerformVoiceSearchSearchErrors$outboundSchema.parse(
+      performVoiceSearchSearchErrors,
+    ),
+  );
+}
+
+export function performVoiceSearchSearchErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<PerformVoiceSearchSearchErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PerformVoiceSearchSearchErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PerformVoiceSearchSearchErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const PerformVoiceSearchUnauthorized$inboundSchema: z.ZodType<
   PerformVoiceSearchUnauthorized,
@@ -236,6 +259,24 @@ export namespace PerformVoiceSearchErrors$ {
   export type Outbound = PerformVoiceSearchErrors$Outbound;
 }
 
+export function performVoiceSearchErrorsToJSON(
+  performVoiceSearchErrors: PerformVoiceSearchErrors,
+): string {
+  return JSON.stringify(
+    PerformVoiceSearchErrors$outboundSchema.parse(performVoiceSearchErrors),
+  );
+}
+
+export function performVoiceSearchErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<PerformVoiceSearchErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PerformVoiceSearchErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PerformVoiceSearchErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const PerformVoiceSearchBadRequest$inboundSchema: z.ZodType<
   PerformVoiceSearchBadRequest,

src/sdk/models/errors/postuserssignindata.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type PostUsersSignInDataAuthenticationErrors = {
   code?: number | undefined;
@@ -137,6 +140,33 @@ export namespace PostUsersSignInDataAuthenticationErrors$ {
   export type Outbound = PostUsersSignInDataAuthenticationErrors$Outbound;
 }
 
+export function postUsersSignInDataAuthenticationErrorsToJSON(
+  postUsersSignInDataAuthenticationErrors:
+    PostUsersSignInDataAuthenticationErrors,
+): string {
+  return JSON.stringify(
+    PostUsersSignInDataAuthenticationErrors$outboundSchema.parse(
+      postUsersSignInDataAuthenticationErrors,
+    ),
+  );
+}
+
+export function postUsersSignInDataAuthenticationErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PostUsersSignInDataAuthenticationErrors,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PostUsersSignInDataAuthenticationErrors$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PostUsersSignInDataAuthenticationErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const PostUsersSignInDataUnauthorized$inboundSchema: z.ZodType<
   PostUsersSignInDataUnauthorized,
@@ -239,6 +269,24 @@ export namespace PostUsersSignInDataErrors$ {
   export type Outbound = PostUsersSignInDataErrors$Outbound;
 }
 
+export function postUsersSignInDataErrorsToJSON(
+  postUsersSignInDataErrors: PostUsersSignInDataErrors,
+): string {
+  return JSON.stringify(
+    PostUsersSignInDataErrors$outboundSchema.parse(postUsersSignInDataErrors),
+  );
+}
+
+export function postUsersSignInDataErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<PostUsersSignInDataErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PostUsersSignInDataErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostUsersSignInDataErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const PostUsersSignInDataBadRequest$inboundSchema: z.ZodType<
   PostUsersSignInDataBadRequest,

src/sdk/models/errors/startalltasks.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type StartAllTasksButlerErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace StartAllTasksButlerErrors$ {
   export type Outbound = StartAllTasksButlerErrors$Outbound;
 }
 
+export function startAllTasksButlerErrorsToJSON(
+  startAllTasksButlerErrors: StartAllTasksButlerErrors,
+): string {
+  return JSON.stringify(
+    StartAllTasksButlerErrors$outboundSchema.parse(startAllTasksButlerErrors),
+  );
+}
+
+export function startAllTasksButlerErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<StartAllTasksButlerErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StartAllTasksButlerErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StartAllTasksButlerErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const StartAllTasksUnauthorized$inboundSchema: z.ZodType<
   StartAllTasksUnauthorized,
@@ -235,6 +256,24 @@ export namespace StartAllTasksErrors$ {
   export type Outbound = StartAllTasksErrors$Outbound;
 }
 
+export function startAllTasksErrorsToJSON(
+  startAllTasksErrors: StartAllTasksErrors,
+): string {
+  return JSON.stringify(
+    StartAllTasksErrors$outboundSchema.parse(startAllTasksErrors),
+  );
+}
+
+export function startAllTasksErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<StartAllTasksErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StartAllTasksErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StartAllTasksErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const StartAllTasksBadRequest$inboundSchema: z.ZodType<
   StartAllTasksBadRequest,

src/sdk/models/errors/starttask.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type StartTaskButlerErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace StartTaskButlerErrors$ {
   export type Outbound = StartTaskButlerErrors$Outbound;
 }
 
+export function startTaskButlerErrorsToJSON(
+  startTaskButlerErrors: StartTaskButlerErrors,
+): string {
+  return JSON.stringify(
+    StartTaskButlerErrors$outboundSchema.parse(startTaskButlerErrors),
+  );
+}
+
+export function startTaskButlerErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<StartTaskButlerErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StartTaskButlerErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StartTaskButlerErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const StartTaskUnauthorized$inboundSchema: z.ZodType<
   StartTaskUnauthorized,
@@ -234,6 +255,22 @@ export namespace StartTaskErrors$ {
   export type Outbound = StartTaskErrors$Outbound;
 }
 
+export function startTaskErrorsToJSON(
+  startTaskErrors: StartTaskErrors,
+): string {
+  return JSON.stringify(StartTaskErrors$outboundSchema.parse(startTaskErrors));
+}
+
+export function startTaskErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<StartTaskErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StartTaskErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StartTaskErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const StartTaskBadRequest$inboundSchema: z.ZodType<
   StartTaskBadRequest,

src/sdk/models/errors/startuniversaltranscode.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type StartUniversalTranscodeVideoErrors = {
   code?: number | undefined;
@@ -136,6 +139,27 @@ export namespace StartUniversalTranscodeVideoErrors$ {
   export type Outbound = StartUniversalTranscodeVideoErrors$Outbound;
 }
 
+export function startUniversalTranscodeVideoErrorsToJSON(
+  startUniversalTranscodeVideoErrors: StartUniversalTranscodeVideoErrors,
+): string {
+  return JSON.stringify(
+    StartUniversalTranscodeVideoErrors$outboundSchema.parse(
+      startUniversalTranscodeVideoErrors,
+    ),
+  );
+}
+
+export function startUniversalTranscodeVideoErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<StartUniversalTranscodeVideoErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      StartUniversalTranscodeVideoErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StartUniversalTranscodeVideoErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const StartUniversalTranscodeUnauthorized$inboundSchema: z.ZodType<
   StartUniversalTranscodeUnauthorized,
@@ -240,6 +264,26 @@ export namespace StartUniversalTranscodeErrors$ {
   export type Outbound = StartUniversalTranscodeErrors$Outbound;
 }
 
+export function startUniversalTranscodeErrorsToJSON(
+  startUniversalTranscodeErrors: StartUniversalTranscodeErrors,
+): string {
+  return JSON.stringify(
+    StartUniversalTranscodeErrors$outboundSchema.parse(
+      startUniversalTranscodeErrors,
+    ),
+  );
+}
+
+export function startUniversalTranscodeErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<StartUniversalTranscodeErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StartUniversalTranscodeErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StartUniversalTranscodeErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const StartUniversalTranscodeBadRequest$inboundSchema: z.ZodType<
   StartUniversalTranscodeBadRequest,

src/sdk/models/errors/stopalltasks.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type StopAllTasksButlerErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace StopAllTasksButlerErrors$ {
   export type Outbound = StopAllTasksButlerErrors$Outbound;
 }
 
+export function stopAllTasksButlerErrorsToJSON(
+  stopAllTasksButlerErrors: StopAllTasksButlerErrors,
+): string {
+  return JSON.stringify(
+    StopAllTasksButlerErrors$outboundSchema.parse(stopAllTasksButlerErrors),
+  );
+}
+
+export function stopAllTasksButlerErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<StopAllTasksButlerErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StopAllTasksButlerErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StopAllTasksButlerErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const StopAllTasksUnauthorized$inboundSchema: z.ZodType<
   StopAllTasksUnauthorized,
@@ -235,6 +256,24 @@ export namespace StopAllTasksErrors$ {
   export type Outbound = StopAllTasksErrors$Outbound;
 }
 
+export function stopAllTasksErrorsToJSON(
+  stopAllTasksErrors: StopAllTasksErrors,
+): string {
+  return JSON.stringify(
+    StopAllTasksErrors$outboundSchema.parse(stopAllTasksErrors),
+  );
+}
+
+export function stopAllTasksErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<StopAllTasksErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StopAllTasksErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StopAllTasksErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const StopAllTasksBadRequest$inboundSchema: z.ZodType<
   StopAllTasksBadRequest,

src/sdk/models/errors/stoptask.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type StopTaskButlerErrors = {
   code?: number | undefined;
@@ -135,6 +138,24 @@ export namespace StopTaskButlerErrors$ {
   export type Outbound = StopTaskButlerErrors$Outbound;
 }
 
+export function stopTaskButlerErrorsToJSON(
+  stopTaskButlerErrors: StopTaskButlerErrors,
+): string {
+  return JSON.stringify(
+    StopTaskButlerErrors$outboundSchema.parse(stopTaskButlerErrors),
+  );
+}
+
+export function stopTaskButlerErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<StopTaskButlerErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StopTaskButlerErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StopTaskButlerErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const StopTaskUnauthorized$inboundSchema: z.ZodType<
   StopTaskUnauthorized,
@@ -234,6 +255,20 @@ export namespace StopTaskErrors$ {
   export type Outbound = StopTaskErrors$Outbound;
 }
 
+export function stopTaskErrorsToJSON(stopTaskErrors: StopTaskErrors): string {
+  return JSON.stringify(StopTaskErrors$outboundSchema.parse(stopTaskErrors));
+}
+
+export function stopTaskErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<StopTaskErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StopTaskErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StopTaskErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const StopTaskBadRequest$inboundSchema: z.ZodType<
   StopTaskBadRequest,

src/sdk/models/errors/stoptranscodesession.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type StopTranscodeSessionSessionsErrors = {
   code?: number | undefined;
@@ -136,6 +139,27 @@ export namespace StopTranscodeSessionSessionsErrors$ {
   export type Outbound = StopTranscodeSessionSessionsErrors$Outbound;
 }
 
+export function stopTranscodeSessionSessionsErrorsToJSON(
+  stopTranscodeSessionSessionsErrors: StopTranscodeSessionSessionsErrors,
+): string {
+  return JSON.stringify(
+    StopTranscodeSessionSessionsErrors$outboundSchema.parse(
+      stopTranscodeSessionSessionsErrors,
+    ),
+  );
+}
+
+export function stopTranscodeSessionSessionsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<StopTranscodeSessionSessionsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      StopTranscodeSessionSessionsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StopTranscodeSessionSessionsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const StopTranscodeSessionUnauthorized$inboundSchema: z.ZodType<
   StopTranscodeSessionUnauthorized,
@@ -238,6 +262,24 @@ export namespace StopTranscodeSessionErrors$ {
   export type Outbound = StopTranscodeSessionErrors$Outbound;
 }
 
+export function stopTranscodeSessionErrorsToJSON(
+  stopTranscodeSessionErrors: StopTranscodeSessionErrors,
+): string {
+  return JSON.stringify(
+    StopTranscodeSessionErrors$outboundSchema.parse(stopTranscodeSessionErrors),
+  );
+}
+
+export function stopTranscodeSessionErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<StopTranscodeSessionErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StopTranscodeSessionErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StopTranscodeSessionErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const StopTranscodeSessionBadRequest$inboundSchema: z.ZodType<
   StopTranscodeSessionBadRequest,

src/sdk/models/errors/updateplaylist.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type UpdatePlaylistPlaylistsErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace UpdatePlaylistPlaylistsErrors$ {
   export type Outbound = UpdatePlaylistPlaylistsErrors$Outbound;
 }
 
+export function updatePlaylistPlaylistsErrorsToJSON(
+  updatePlaylistPlaylistsErrors: UpdatePlaylistPlaylistsErrors,
+): string {
+  return JSON.stringify(
+    UpdatePlaylistPlaylistsErrors$outboundSchema.parse(
+      updatePlaylistPlaylistsErrors,
+    ),
+  );
+}
+
+export function updatePlaylistPlaylistsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdatePlaylistPlaylistsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdatePlaylistPlaylistsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdatePlaylistPlaylistsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdatePlaylistUnauthorized$inboundSchema: z.ZodType<
   UpdatePlaylistUnauthorized,
@@ -236,6 +259,24 @@ export namespace UpdatePlaylistErrors$ {
   export type Outbound = UpdatePlaylistErrors$Outbound;
 }
 
+export function updatePlaylistErrorsToJSON(
+  updatePlaylistErrors: UpdatePlaylistErrors,
+): string {
+  return JSON.stringify(
+    UpdatePlaylistErrors$outboundSchema.parse(updatePlaylistErrors),
+  );
+}
+
+export function updatePlaylistErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdatePlaylistErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdatePlaylistErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdatePlaylistErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdatePlaylistBadRequest$inboundSchema: z.ZodType<
   UpdatePlaylistBadRequest,

src/sdk/models/errors/updateplayprogress.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type UpdatePlayProgressMediaErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace UpdatePlayProgressMediaErrors$ {
   export type Outbound = UpdatePlayProgressMediaErrors$Outbound;
 }
 
+export function updatePlayProgressMediaErrorsToJSON(
+  updatePlayProgressMediaErrors: UpdatePlayProgressMediaErrors,
+): string {
+  return JSON.stringify(
+    UpdatePlayProgressMediaErrors$outboundSchema.parse(
+      updatePlayProgressMediaErrors,
+    ),
+  );
+}
+
+export function updatePlayProgressMediaErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdatePlayProgressMediaErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdatePlayProgressMediaErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdatePlayProgressMediaErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdatePlayProgressUnauthorized$inboundSchema: z.ZodType<
   UpdatePlayProgressUnauthorized,
@@ -236,6 +259,24 @@ export namespace UpdatePlayProgressErrors$ {
   export type Outbound = UpdatePlayProgressErrors$Outbound;
 }
 
+export function updatePlayProgressErrorsToJSON(
+  updatePlayProgressErrors: UpdatePlayProgressErrors,
+): string {
+  return JSON.stringify(
+    UpdatePlayProgressErrors$outboundSchema.parse(updatePlayProgressErrors),
+  );
+}
+
+export function updatePlayProgressErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdatePlayProgressErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdatePlayProgressErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdatePlayProgressErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdatePlayProgressBadRequest$inboundSchema: z.ZodType<
   UpdatePlayProgressBadRequest,

src/sdk/models/errors/uploadplaylist.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 export type UploadPlaylistPlaylistsErrors = {
   code?: number | undefined;
@@ -135,6 +138,26 @@ export namespace UploadPlaylistPlaylistsErrors$ {
   export type Outbound = UploadPlaylistPlaylistsErrors$Outbound;
 }
 
+export function uploadPlaylistPlaylistsErrorsToJSON(
+  uploadPlaylistPlaylistsErrors: UploadPlaylistPlaylistsErrors,
+): string {
+  return JSON.stringify(
+    UploadPlaylistPlaylistsErrors$outboundSchema.parse(
+      uploadPlaylistPlaylistsErrors,
+    ),
+  );
+}
+
+export function uploadPlaylistPlaylistsErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<UploadPlaylistPlaylistsErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UploadPlaylistPlaylistsErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UploadPlaylistPlaylistsErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const UploadPlaylistUnauthorized$inboundSchema: z.ZodType<
   UploadPlaylistUnauthorized,
@@ -236,6 +259,24 @@ export namespace UploadPlaylistErrors$ {
   export type Outbound = UploadPlaylistErrors$Outbound;
 }
 
+export function uploadPlaylistErrorsToJSON(
+  uploadPlaylistErrors: UploadPlaylistErrors,
+): string {
+  return JSON.stringify(
+    UploadPlaylistErrors$outboundSchema.parse(uploadPlaylistErrors),
+  );
+}
+
+export function uploadPlaylistErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<UploadPlaylistErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UploadPlaylistErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UploadPlaylistErrors' from JSON`,
+  );
+}
+
 /** @internal */
 export const UploadPlaylistBadRequest$inboundSchema: z.ZodType<
   UploadPlaylistBadRequest,

src/sdk/models/operations/addplaylistcontents.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type AddPlaylistContentsRequest = {
   /**
@@ -111,6 +114,24 @@ export namespace AddPlaylistContentsRequest$ {
   export type Outbound = AddPlaylistContentsRequest$Outbound;
 }
 
+export function addPlaylistContentsRequestToJSON(
+  addPlaylistContentsRequest: AddPlaylistContentsRequest,
+): string {
+  return JSON.stringify(
+    AddPlaylistContentsRequest$outboundSchema.parse(addPlaylistContentsRequest),
+  );
+}
+
+export function addPlaylistContentsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<AddPlaylistContentsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddPlaylistContentsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddPlaylistContentsRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const AddPlaylistContentsMetadata$inboundSchema: z.ZodType<
   AddPlaylistContentsMetadata,
@@ -183,6 +204,26 @@ export namespace AddPlaylistContentsMetadata$ {
   export type Outbound = AddPlaylistContentsMetadata$Outbound;
 }
 
+export function addPlaylistContentsMetadataToJSON(
+  addPlaylistContentsMetadata: AddPlaylistContentsMetadata,
+): string {
+  return JSON.stringify(
+    AddPlaylistContentsMetadata$outboundSchema.parse(
+      addPlaylistContentsMetadata,
+    ),
+  );
+}
+
+export function addPlaylistContentsMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<AddPlaylistContentsMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddPlaylistContentsMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddPlaylistContentsMetadata' from JSON`,
+  );
+}
+
 /** @internal */
 export const AddPlaylistContentsMediaContainer$inboundSchema: z.ZodType<
   AddPlaylistContentsMediaContainer,
@@ -239,6 +280,26 @@ export namespace AddPlaylistContentsMediaContainer$ {
   export type Outbound = AddPlaylistContentsMediaContainer$Outbound;
 }
 
+export function addPlaylistContentsMediaContainerToJSON(
+  addPlaylistContentsMediaContainer: AddPlaylistContentsMediaContainer,
+): string {
+  return JSON.stringify(
+    AddPlaylistContentsMediaContainer$outboundSchema.parse(
+      addPlaylistContentsMediaContainer,
+    ),
+  );
+}
+
+export function addPlaylistContentsMediaContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<AddPlaylistContentsMediaContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddPlaylistContentsMediaContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddPlaylistContentsMediaContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const AddPlaylistContentsResponseBody$inboundSchema: z.ZodType<
   AddPlaylistContentsResponseBody,
@@ -285,6 +346,26 @@ export namespace AddPlaylistContentsResponseBody$ {
   export type Outbound = AddPlaylistContentsResponseBody$Outbound;
 }
 
+export function addPlaylistContentsResponseBodyToJSON(
+  addPlaylistContentsResponseBody: AddPlaylistContentsResponseBody,
+): string {
+  return JSON.stringify(
+    AddPlaylistContentsResponseBody$outboundSchema.parse(
+      addPlaylistContentsResponseBody,
+    ),
+  );
+}
+
+export function addPlaylistContentsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<AddPlaylistContentsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddPlaylistContentsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddPlaylistContentsResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const AddPlaylistContentsResponse$inboundSchema: z.ZodType<
   AddPlaylistContentsResponse,
@@ -345,3 +426,23 @@ export namespace AddPlaylistContentsResponse$ {
   /** @deprecated use `AddPlaylistContentsResponse$Outbound` instead. */
   export type Outbound = AddPlaylistContentsResponse$Outbound;
 }
+
+export function addPlaylistContentsResponseToJSON(
+  addPlaylistContentsResponse: AddPlaylistContentsResponse,
+): string {
+  return JSON.stringify(
+    AddPlaylistContentsResponse$outboundSchema.parse(
+      addPlaylistContentsResponse,
+    ),
+  );
+}
+
+export function addPlaylistContentsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AddPlaylistContentsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddPlaylistContentsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddPlaylistContentsResponse' from JSON`,
+  );
+}

src/sdk/models/operations/applyupdates.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * Indicate that you want the update to run during the next Butler execution. Omitting this or setting it to false indicates that the update should install
@@ -125,6 +128,24 @@ export namespace ApplyUpdatesRequest$ {
   export type Outbound = ApplyUpdatesRequest$Outbound;
 }
 
+export function applyUpdatesRequestToJSON(
+  applyUpdatesRequest: ApplyUpdatesRequest,
+): string {
+  return JSON.stringify(
+    ApplyUpdatesRequest$outboundSchema.parse(applyUpdatesRequest),
+  );
+}
+
+export function applyUpdatesRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ApplyUpdatesRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ApplyUpdatesRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ApplyUpdatesRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const ApplyUpdatesResponse$inboundSchema: z.ZodType<
   ApplyUpdatesResponse,
@@ -180,3 +201,21 @@ export namespace ApplyUpdatesResponse$ {
   /** @deprecated use `ApplyUpdatesResponse$Outbound` instead. */
   export type Outbound = ApplyUpdatesResponse$Outbound;
 }
+
+export function applyUpdatesResponseToJSON(
+  applyUpdatesResponse: ApplyUpdatesResponse,
+): string {
+  return JSON.stringify(
+    ApplyUpdatesResponse$outboundSchema.parse(applyUpdatesResponse),
+  );
+}
+
+export function applyUpdatesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ApplyUpdatesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ApplyUpdatesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ApplyUpdatesResponse' from JSON`,
+  );
+}

src/sdk/models/operations/cancelserveractivities.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type CancelServerActivitiesRequest = {
   /**
@@ -63,6 +66,26 @@ export namespace CancelServerActivitiesRequest$ {
   export type Outbound = CancelServerActivitiesRequest$Outbound;
 }
 
+export function cancelServerActivitiesRequestToJSON(
+  cancelServerActivitiesRequest: CancelServerActivitiesRequest,
+): string {
+  return JSON.stringify(
+    CancelServerActivitiesRequest$outboundSchema.parse(
+      cancelServerActivitiesRequest,
+    ),
+  );
+}
+
+export function cancelServerActivitiesRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CancelServerActivitiesRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CancelServerActivitiesRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CancelServerActivitiesRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const CancelServerActivitiesResponse$inboundSchema: z.ZodType<
   CancelServerActivitiesResponse,
@@ -118,3 +141,23 @@ export namespace CancelServerActivitiesResponse$ {
   /** @deprecated use `CancelServerActivitiesResponse$Outbound` instead. */
   export type Outbound = CancelServerActivitiesResponse$Outbound;
 }
+
+export function cancelServerActivitiesResponseToJSON(
+  cancelServerActivitiesResponse: CancelServerActivitiesResponse,
+): string {
+  return JSON.stringify(
+    CancelServerActivitiesResponse$outboundSchema.parse(
+      cancelServerActivitiesResponse,
+    ),
+  );
+}
+
+export function cancelServerActivitiesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CancelServerActivitiesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CancelServerActivitiesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CancelServerActivitiesResponse' from JSON`,
+  );
+}

src/sdk/models/operations/checkforupdates.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * Indicate that you want to start download any updates found.
@@ -90,6 +93,24 @@ export namespace CheckForUpdatesRequest$ {
   export type Outbound = CheckForUpdatesRequest$Outbound;
 }
 
+export function checkForUpdatesRequestToJSON(
+  checkForUpdatesRequest: CheckForUpdatesRequest,
+): string {
+  return JSON.stringify(
+    CheckForUpdatesRequest$outboundSchema.parse(checkForUpdatesRequest),
+  );
+}
+
+export function checkForUpdatesRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CheckForUpdatesRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CheckForUpdatesRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CheckForUpdatesRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const CheckForUpdatesResponse$inboundSchema: z.ZodType<
   CheckForUpdatesResponse,
@@ -145,3 +166,21 @@ export namespace CheckForUpdatesResponse$ {
   /** @deprecated use `CheckForUpdatesResponse$Outbound` instead. */
   export type Outbound = CheckForUpdatesResponse$Outbound;
 }
+
+export function checkForUpdatesResponseToJSON(
+  checkForUpdatesResponse: CheckForUpdatesResponse,
+): string {
+  return JSON.stringify(
+    CheckForUpdatesResponse$outboundSchema.parse(checkForUpdatesResponse),
+  );
+}
+
+export function checkForUpdatesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CheckForUpdatesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CheckForUpdatesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CheckForUpdatesResponse' from JSON`,
+  );
+}

src/sdk/models/operations/clearplaylistcontents.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type ClearPlaylistContentsRequest = {
   /**
@@ -63,6 +66,26 @@ export namespace ClearPlaylistContentsRequest$ {
   export type Outbound = ClearPlaylistContentsRequest$Outbound;
 }
 
+export function clearPlaylistContentsRequestToJSON(
+  clearPlaylistContentsRequest: ClearPlaylistContentsRequest,
+): string {
+  return JSON.stringify(
+    ClearPlaylistContentsRequest$outboundSchema.parse(
+      clearPlaylistContentsRequest,
+    ),
+  );
+}
+
+export function clearPlaylistContentsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ClearPlaylistContentsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ClearPlaylistContentsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ClearPlaylistContentsRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const ClearPlaylistContentsResponse$inboundSchema: z.ZodType<
   ClearPlaylistContentsResponse,
@@ -118,3 +141,23 @@ export namespace ClearPlaylistContentsResponse$ {
   /** @deprecated use `ClearPlaylistContentsResponse$Outbound` instead. */
   export type Outbound = ClearPlaylistContentsResponse$Outbound;
 }
+
+export function clearPlaylistContentsResponseToJSON(
+  clearPlaylistContentsResponse: ClearPlaylistContentsResponse,
+): string {
+  return JSON.stringify(
+    ClearPlaylistContentsResponse$outboundSchema.parse(
+      clearPlaylistContentsResponse,
+    ),
+  );
+}
+
+export function clearPlaylistContentsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ClearPlaylistContentsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ClearPlaylistContentsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ClearPlaylistContentsResponse' from JSON`,
+  );
+}

src/sdk/models/operations/createplaylist.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * type of playlist to create
@@ -184,6 +187,24 @@ export namespace CreatePlaylistRequest$ {
   export type Outbound = CreatePlaylistRequest$Outbound;
 }
 
+export function createPlaylistRequestToJSON(
+  createPlaylistRequest: CreatePlaylistRequest,
+): string {
+  return JSON.stringify(
+    CreatePlaylistRequest$outboundSchema.parse(createPlaylistRequest),
+  );
+}
+
+export function createPlaylistRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreatePlaylistRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreatePlaylistRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreatePlaylistRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreatePlaylistMetadata$inboundSchema: z.ZodType<
   CreatePlaylistMetadata,
@@ -265,6 +286,24 @@ export namespace CreatePlaylistMetadata$ {
   export type Outbound = CreatePlaylistMetadata$Outbound;
 }
 
+export function createPlaylistMetadataToJSON(
+  createPlaylistMetadata: CreatePlaylistMetadata,
+): string {
+  return JSON.stringify(
+    CreatePlaylistMetadata$outboundSchema.parse(createPlaylistMetadata),
+  );
+}
+
+export function createPlaylistMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<CreatePlaylistMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreatePlaylistMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreatePlaylistMetadata' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreatePlaylistMediaContainer$inboundSchema: z.ZodType<
   CreatePlaylistMediaContainer,
@@ -314,6 +353,26 @@ export namespace CreatePlaylistMediaContainer$ {
   export type Outbound = CreatePlaylistMediaContainer$Outbound;
 }
 
+export function createPlaylistMediaContainerToJSON(
+  createPlaylistMediaContainer: CreatePlaylistMediaContainer,
+): string {
+  return JSON.stringify(
+    CreatePlaylistMediaContainer$outboundSchema.parse(
+      createPlaylistMediaContainer,
+    ),
+  );
+}
+
+export function createPlaylistMediaContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<CreatePlaylistMediaContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreatePlaylistMediaContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreatePlaylistMediaContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreatePlaylistResponseBody$inboundSchema: z.ZodType<
   CreatePlaylistResponseBody,
@@ -360,6 +419,24 @@ export namespace CreatePlaylistResponseBody$ {
   export type Outbound = CreatePlaylistResponseBody$Outbound;
 }
 
+export function createPlaylistResponseBodyToJSON(
+  createPlaylistResponseBody: CreatePlaylistResponseBody,
+): string {
+  return JSON.stringify(
+    CreatePlaylistResponseBody$outboundSchema.parse(createPlaylistResponseBody),
+  );
+}
+
+export function createPlaylistResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreatePlaylistResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreatePlaylistResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreatePlaylistResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreatePlaylistResponse$inboundSchema: z.ZodType<
   CreatePlaylistResponse,
@@ -418,3 +495,21 @@ export namespace CreatePlaylistResponse$ {
   /** @deprecated use `CreatePlaylistResponse$Outbound` instead. */
   export type Outbound = CreatePlaylistResponse$Outbound;
 }
+
+export function createPlaylistResponseToJSON(
+  createPlaylistResponse: CreatePlaylistResponse,
+): string {
+  return JSON.stringify(
+    CreatePlaylistResponse$outboundSchema.parse(createPlaylistResponse),
+  );
+}
+
+export function createPlaylistResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreatePlaylistResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreatePlaylistResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreatePlaylistResponse' from JSON`,
+  );
+}

src/sdk/models/operations/deletelibrary.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type DeleteLibraryRequest = {
   /**
@@ -66,6 +69,24 @@ export namespace DeleteLibraryRequest$ {
   export type Outbound = DeleteLibraryRequest$Outbound;
 }
 
+export function deleteLibraryRequestToJSON(
+  deleteLibraryRequest: DeleteLibraryRequest,
+): string {
+  return JSON.stringify(
+    DeleteLibraryRequest$outboundSchema.parse(deleteLibraryRequest),
+  );
+}
+
+export function deleteLibraryRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteLibraryRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteLibraryRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteLibraryRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const DeleteLibraryResponse$inboundSchema: z.ZodType<
   DeleteLibraryResponse,
@@ -121,3 +142,21 @@ export namespace DeleteLibraryResponse$ {
   /** @deprecated use `DeleteLibraryResponse$Outbound` instead. */
   export type Outbound = DeleteLibraryResponse$Outbound;
 }
+
+export function deleteLibraryResponseToJSON(
+  deleteLibraryResponse: DeleteLibraryResponse,
+): string {
+  return JSON.stringify(
+    DeleteLibraryResponse$outboundSchema.parse(deleteLibraryResponse),
+  );
+}
+
+export function deleteLibraryResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteLibraryResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteLibraryResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteLibraryResponse' from JSON`,
+  );
+}

src/sdk/models/operations/deleteplaylist.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type DeletePlaylistRequest = {
   /**
@@ -63,6 +66,24 @@ export namespace DeletePlaylistRequest$ {
   export type Outbound = DeletePlaylistRequest$Outbound;
 }
 
+export function deletePlaylistRequestToJSON(
+  deletePlaylistRequest: DeletePlaylistRequest,
+): string {
+  return JSON.stringify(
+    DeletePlaylistRequest$outboundSchema.parse(deletePlaylistRequest),
+  );
+}
+
+export function deletePlaylistRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<DeletePlaylistRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeletePlaylistRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeletePlaylistRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const DeletePlaylistResponse$inboundSchema: z.ZodType<
   DeletePlaylistResponse,
@@ -118,3 +139,21 @@ export namespace DeletePlaylistResponse$ {
   /** @deprecated use `DeletePlaylistResponse$Outbound` instead. */
   export type Outbound = DeletePlaylistResponse$Outbound;
 }
+
+export function deletePlaylistResponseToJSON(
+  deletePlaylistResponse: DeletePlaylistResponse,
+): string {
+  return JSON.stringify(
+    DeletePlaylistResponse$outboundSchema.parse(deletePlaylistResponse),
+  );
+}
+
+export function deletePlaylistResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeletePlaylistResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeletePlaylistResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeletePlaylistResponse' from JSON`,
+  );
+}

src/sdk/models/operations/enablepapertrail.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type EnablePaperTrailResponse = {
   /**
@@ -75,3 +78,21 @@ export namespace EnablePaperTrailResponse$ {
   /** @deprecated use `EnablePaperTrailResponse$Outbound` instead. */
   export type Outbound = EnablePaperTrailResponse$Outbound;
 }
+
+export function enablePaperTrailResponseToJSON(
+  enablePaperTrailResponse: EnablePaperTrailResponse,
+): string {
+  return JSON.stringify(
+    EnablePaperTrailResponse$outboundSchema.parse(enablePaperTrailResponse),
+  );
+}
+
+export function enablePaperTrailResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<EnablePaperTrailResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnablePaperTrailResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnablePaperTrailResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getalllibraries.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type GetAllLibrariesLocation = {
   id: number;
@@ -118,6 +121,24 @@ export namespace GetAllLibrariesLocation$ {
   export type Outbound = GetAllLibrariesLocation$Outbound;
 }
 
+export function getAllLibrariesLocationToJSON(
+  getAllLibrariesLocation: GetAllLibrariesLocation,
+): string {
+  return JSON.stringify(
+    GetAllLibrariesLocation$outboundSchema.parse(getAllLibrariesLocation),
+  );
+}
+
+export function getAllLibrariesLocationFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAllLibrariesLocation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAllLibrariesLocation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAllLibrariesLocation' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetAllLibrariesDirectory$inboundSchema: z.ZodType<
   GetAllLibrariesDirectory,
@@ -222,6 +243,24 @@ export namespace GetAllLibrariesDirectory$ {
   export type Outbound = GetAllLibrariesDirectory$Outbound;
 }
 
+export function getAllLibrariesDirectoryToJSON(
+  getAllLibrariesDirectory: GetAllLibrariesDirectory,
+): string {
+  return JSON.stringify(
+    GetAllLibrariesDirectory$outboundSchema.parse(getAllLibrariesDirectory),
+  );
+}
+
+export function getAllLibrariesDirectoryFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAllLibrariesDirectory, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAllLibrariesDirectory$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAllLibrariesDirectory' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetAllLibrariesMediaContainer$inboundSchema: z.ZodType<
   GetAllLibrariesMediaContainer,
@@ -275,6 +314,26 @@ export namespace GetAllLibrariesMediaContainer$ {
   export type Outbound = GetAllLibrariesMediaContainer$Outbound;
 }
 
+export function getAllLibrariesMediaContainerToJSON(
+  getAllLibrariesMediaContainer: GetAllLibrariesMediaContainer,
+): string {
+  return JSON.stringify(
+    GetAllLibrariesMediaContainer$outboundSchema.parse(
+      getAllLibrariesMediaContainer,
+    ),
+  );
+}
+
+export function getAllLibrariesMediaContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAllLibrariesMediaContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAllLibrariesMediaContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAllLibrariesMediaContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetAllLibrariesResponseBody$inboundSchema: z.ZodType<
   GetAllLibrariesResponseBody,
@@ -319,6 +378,26 @@ export namespace GetAllLibrariesResponseBody$ {
   export type Outbound = GetAllLibrariesResponseBody$Outbound;
 }
 
+export function getAllLibrariesResponseBodyToJSON(
+  getAllLibrariesResponseBody: GetAllLibrariesResponseBody,
+): string {
+  return JSON.stringify(
+    GetAllLibrariesResponseBody$outboundSchema.parse(
+      getAllLibrariesResponseBody,
+    ),
+  );
+}
+
+export function getAllLibrariesResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAllLibrariesResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAllLibrariesResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAllLibrariesResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetAllLibrariesResponse$inboundSchema: z.ZodType<
   GetAllLibrariesResponse,
@@ -377,3 +456,21 @@ export namespace GetAllLibrariesResponse$ {
   /** @deprecated use `GetAllLibrariesResponse$Outbound` instead. */
   export type Outbound = GetAllLibrariesResponse$Outbound;
 }
+
+export function getAllLibrariesResponseToJSON(
+  getAllLibrariesResponse: GetAllLibrariesResponse,
+): string {
+  return JSON.stringify(
+    GetAllLibrariesResponse$outboundSchema.parse(getAllLibrariesResponse),
+  );
+}
+
+export function getAllLibrariesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAllLibrariesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAllLibrariesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAllLibrariesResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getavailableclients.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type Server = {
   name?: string | undefined;
@@ -113,6 +116,20 @@ export namespace Server$ {
   export type Outbound = Server$Outbound;
 }
 
+export function serverToJSON(server: Server): string {
+  return JSON.stringify(Server$outboundSchema.parse(server));
+}
+
+export function serverFromJSON(
+  jsonString: string,
+): SafeParseResult<Server, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Server$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Server' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetAvailableClientsMediaContainer$inboundSchema: z.ZodType<
   GetAvailableClientsMediaContainer,
@@ -161,6 +178,26 @@ export namespace GetAvailableClientsMediaContainer$ {
   export type Outbound = GetAvailableClientsMediaContainer$Outbound;
 }
 
+export function getAvailableClientsMediaContainerToJSON(
+  getAvailableClientsMediaContainer: GetAvailableClientsMediaContainer,
+): string {
+  return JSON.stringify(
+    GetAvailableClientsMediaContainer$outboundSchema.parse(
+      getAvailableClientsMediaContainer,
+    ),
+  );
+}
+
+export function getAvailableClientsMediaContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAvailableClientsMediaContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAvailableClientsMediaContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAvailableClientsMediaContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetAvailableClientsResponseBody$inboundSchema: z.ZodType<
   GetAvailableClientsResponseBody,
@@ -207,6 +244,26 @@ export namespace GetAvailableClientsResponseBody$ {
   export type Outbound = GetAvailableClientsResponseBody$Outbound;
 }
 
+export function getAvailableClientsResponseBodyToJSON(
+  getAvailableClientsResponseBody: GetAvailableClientsResponseBody,
+): string {
+  return JSON.stringify(
+    GetAvailableClientsResponseBody$outboundSchema.parse(
+      getAvailableClientsResponseBody,
+    ),
+  );
+}
+
+export function getAvailableClientsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAvailableClientsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAvailableClientsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAvailableClientsResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetAvailableClientsResponse$inboundSchema: z.ZodType<
   GetAvailableClientsResponse,
@@ -267,3 +324,23 @@ export namespace GetAvailableClientsResponse$ {
   /** @deprecated use `GetAvailableClientsResponse$Outbound` instead. */
   export type Outbound = GetAvailableClientsResponse$Outbound;
 }
+
+export function getAvailableClientsResponseToJSON(
+  getAvailableClientsResponse: GetAvailableClientsResponse,
+): string {
+  return JSON.stringify(
+    GetAvailableClientsResponse$outboundSchema.parse(
+      getAvailableClientsResponse,
+    ),
+  );
+}
+
+export function getAvailableClientsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAvailableClientsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAvailableClientsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAvailableClientsResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getbandwidthstatistics.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type GetBandwidthStatisticsRequest = {
   /**
@@ -112,6 +115,26 @@ export namespace GetBandwidthStatisticsRequest$ {
   export type Outbound = GetBandwidthStatisticsRequest$Outbound;
 }
 
+export function getBandwidthStatisticsRequestToJSON(
+  getBandwidthStatisticsRequest: GetBandwidthStatisticsRequest,
+): string {
+  return JSON.stringify(
+    GetBandwidthStatisticsRequest$outboundSchema.parse(
+      getBandwidthStatisticsRequest,
+    ),
+  );
+}
+
+export function getBandwidthStatisticsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetBandwidthStatisticsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetBandwidthStatisticsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetBandwidthStatisticsRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetBandwidthStatisticsDevice$inboundSchema: z.ZodType<
   GetBandwidthStatisticsDevice,
@@ -160,6 +183,26 @@ export namespace GetBandwidthStatisticsDevice$ {
   export type Outbound = GetBandwidthStatisticsDevice$Outbound;
 }
 
+export function getBandwidthStatisticsDeviceToJSON(
+  getBandwidthStatisticsDevice: GetBandwidthStatisticsDevice,
+): string {
+  return JSON.stringify(
+    GetBandwidthStatisticsDevice$outboundSchema.parse(
+      getBandwidthStatisticsDevice,
+    ),
+  );
+}
+
+export function getBandwidthStatisticsDeviceFromJSON(
+  jsonString: string,
+): SafeParseResult<GetBandwidthStatisticsDevice, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetBandwidthStatisticsDevice$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetBandwidthStatisticsDevice' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetBandwidthStatisticsAccount$inboundSchema: z.ZodType<
   GetBandwidthStatisticsAccount,
@@ -217,6 +260,26 @@ export namespace GetBandwidthStatisticsAccount$ {
   export type Outbound = GetBandwidthStatisticsAccount$Outbound;
 }
 
+export function getBandwidthStatisticsAccountToJSON(
+  getBandwidthStatisticsAccount: GetBandwidthStatisticsAccount,
+): string {
+  return JSON.stringify(
+    GetBandwidthStatisticsAccount$outboundSchema.parse(
+      getBandwidthStatisticsAccount,
+    ),
+  );
+}
+
+export function getBandwidthStatisticsAccountFromJSON(
+  jsonString: string,
+): SafeParseResult<GetBandwidthStatisticsAccount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetBandwidthStatisticsAccount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetBandwidthStatisticsAccount' from JSON`,
+  );
+}
+
 /** @internal */
 export const StatisticsBandwidth$inboundSchema: z.ZodType<
   StatisticsBandwidth,
@@ -268,6 +331,24 @@ export namespace StatisticsBandwidth$ {
   export type Outbound = StatisticsBandwidth$Outbound;
 }
 
+export function statisticsBandwidthToJSON(
+  statisticsBandwidth: StatisticsBandwidth,
+): string {
+  return JSON.stringify(
+    StatisticsBandwidth$outboundSchema.parse(statisticsBandwidth),
+  );
+}
+
+export function statisticsBandwidthFromJSON(
+  jsonString: string,
+): SafeParseResult<StatisticsBandwidth, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StatisticsBandwidth$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StatisticsBandwidth' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetBandwidthStatisticsMediaContainer$inboundSchema: z.ZodType<
   GetBandwidthStatisticsMediaContainer,
@@ -333,6 +414,27 @@ export namespace GetBandwidthStatisticsMediaContainer$ {
   export type Outbound = GetBandwidthStatisticsMediaContainer$Outbound;
 }
 
+export function getBandwidthStatisticsMediaContainerToJSON(
+  getBandwidthStatisticsMediaContainer: GetBandwidthStatisticsMediaContainer,
+): string {
+  return JSON.stringify(
+    GetBandwidthStatisticsMediaContainer$outboundSchema.parse(
+      getBandwidthStatisticsMediaContainer,
+    ),
+  );
+}
+
+export function getBandwidthStatisticsMediaContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<GetBandwidthStatisticsMediaContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetBandwidthStatisticsMediaContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetBandwidthStatisticsMediaContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetBandwidthStatisticsResponseBody$inboundSchema: z.ZodType<
   GetBandwidthStatisticsResponseBody,
@@ -382,6 +484,27 @@ export namespace GetBandwidthStatisticsResponseBody$ {
   export type Outbound = GetBandwidthStatisticsResponseBody$Outbound;
 }
 
+export function getBandwidthStatisticsResponseBodyToJSON(
+  getBandwidthStatisticsResponseBody: GetBandwidthStatisticsResponseBody,
+): string {
+  return JSON.stringify(
+    GetBandwidthStatisticsResponseBody$outboundSchema.parse(
+      getBandwidthStatisticsResponseBody,
+    ),
+  );
+}
+
+export function getBandwidthStatisticsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetBandwidthStatisticsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetBandwidthStatisticsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetBandwidthStatisticsResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetBandwidthStatisticsResponse$inboundSchema: z.ZodType<
   GetBandwidthStatisticsResponse,
@@ -442,3 +565,23 @@ export namespace GetBandwidthStatisticsResponse$ {
   /** @deprecated use `GetBandwidthStatisticsResponse$Outbound` instead. */
   export type Outbound = GetBandwidthStatisticsResponse$Outbound;
 }
+
+export function getBandwidthStatisticsResponseToJSON(
+  getBandwidthStatisticsResponse: GetBandwidthStatisticsResponse,
+): string {
+  return JSON.stringify(
+    GetBandwidthStatisticsResponse$outboundSchema.parse(
+      getBandwidthStatisticsResponse,
+    ),
+  );
+}
+
+export function getBandwidthStatisticsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetBandwidthStatisticsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetBandwidthStatisticsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetBandwidthStatisticsResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getbannerimage.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type GetBannerImageRequest = {
   /**
@@ -99,6 +102,24 @@ export namespace GetBannerImageRequest$ {
   export type Outbound = GetBannerImageRequest$Outbound;
 }
 
+export function getBannerImageRequestToJSON(
+  getBannerImageRequest: GetBannerImageRequest,
+): string {
+  return JSON.stringify(
+    GetBannerImageRequest$outboundSchema.parse(getBannerImageRequest),
+  );
+}
+
+export function getBannerImageRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetBannerImageRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetBannerImageRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetBannerImageRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetBannerImageResponse$inboundSchema: z.ZodType<
   GetBannerImageResponse,
@@ -164,3 +185,21 @@ export namespace GetBannerImageResponse$ {
   /** @deprecated use `GetBannerImageResponse$Outbound` instead. */
   export type Outbound = GetBannerImageResponse$Outbound;
 }
+
+export function getBannerImageResponseToJSON(
+  getBannerImageResponse: GetBannerImageResponse,
+): string {
+  return JSON.stringify(
+    GetBannerImageResponse$outboundSchema.parse(getBannerImageResponse),
+  );
+}
+
+export function getBannerImageResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetBannerImageResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetBannerImageResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetBannerImageResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getbutlertasks.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type ButlerTask = {
   name?: string | undefined;
@@ -95,6 +98,20 @@ export namespace ButlerTask$ {
   export type Outbound = ButlerTask$Outbound;
 }
 
+export function butlerTaskToJSON(butlerTask: ButlerTask): string {
+  return JSON.stringify(ButlerTask$outboundSchema.parse(butlerTask));
+}
+
+export function butlerTaskFromJSON(
+  jsonString: string,
+): SafeParseResult<ButlerTask, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ButlerTask$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ButlerTask' from JSON`,
+  );
+}
+
 /** @internal */
 export const ButlerTasks$inboundSchema: z.ZodType<
   ButlerTasks,
@@ -139,6 +156,20 @@ export namespace ButlerTasks$ {
   export type Outbound = ButlerTasks$Outbound;
 }
 
+export function butlerTasksToJSON(butlerTasks: ButlerTasks): string {
+  return JSON.stringify(ButlerTasks$outboundSchema.parse(butlerTasks));
+}
+
+export function butlerTasksFromJSON(
+  jsonString: string,
+): SafeParseResult<ButlerTasks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ButlerTasks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ButlerTasks' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetButlerTasksResponseBody$inboundSchema: z.ZodType<
   GetButlerTasksResponseBody,
@@ -183,6 +214,24 @@ export namespace GetButlerTasksResponseBody$ {
   export type Outbound = GetButlerTasksResponseBody$Outbound;
 }
 
+export function getButlerTasksResponseBodyToJSON(
+  getButlerTasksResponseBody: GetButlerTasksResponseBody,
+): string {
+  return JSON.stringify(
+    GetButlerTasksResponseBody$outboundSchema.parse(getButlerTasksResponseBody),
+  );
+}
+
+export function getButlerTasksResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetButlerTasksResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetButlerTasksResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetButlerTasksResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetButlerTasksResponse$inboundSchema: z.ZodType<
   GetButlerTasksResponse,
@@ -241,3 +290,21 @@ export namespace GetButlerTasksResponse$ {
   /** @deprecated use `GetButlerTasksResponse$Outbound` instead. */
   export type Outbound = GetButlerTasksResponse$Outbound;
 }
+
+export function getButlerTasksResponseToJSON(
+  getButlerTasksResponse: GetButlerTasksResponse,
+): string {
+  return JSON.stringify(
+    GetButlerTasksResponse$outboundSchema.parse(getButlerTasksResponse),
+  );
+}
+
+export function getButlerTasksResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetButlerTasksResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetButlerTasksResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetButlerTasksResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getcompanionsdata.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const GetCompanionsDataServerList = [
   "https://plex.tv/api/v2",
@@ -91,6 +94,20 @@ export namespace ResponseBody$ {
   export type Outbound = ResponseBody$Outbound;
 }
 
+export function responseBodyToJSON(responseBody: ResponseBody): string {
+  return JSON.stringify(ResponseBody$outboundSchema.parse(responseBody));
+}
+
+export function responseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetCompanionsDataResponse$inboundSchema: z.ZodType<
   GetCompanionsDataResponse,
@@ -149,3 +166,21 @@ export namespace GetCompanionsDataResponse$ {
   /** @deprecated use `GetCompanionsDataResponse$Outbound` instead. */
   export type Outbound = GetCompanionsDataResponse$Outbound;
 }
+
+export function getCompanionsDataResponseToJSON(
+  getCompanionsDataResponse: GetCompanionsDataResponse,
+): string {
+  return JSON.stringify(
+    GetCompanionsDataResponse$outboundSchema.parse(getCompanionsDataResponse),
+  );
+}
+
+export function getCompanionsDataResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetCompanionsDataResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetCompanionsDataResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetCompanionsDataResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getdevices.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type Device = {
   id?: number | undefined;
@@ -90,6 +93,20 @@ export namespace Device$ {
   export type Outbound = Device$Outbound;
 }
 
+export function deviceToJSON(device: Device): string {
+  return JSON.stringify(Device$outboundSchema.parse(device));
+}
+
+export function deviceFromJSON(
+  jsonString: string,
+): SafeParseResult<Device, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Device$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Device' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetDevicesMediaContainer$inboundSchema: z.ZodType<
   GetDevicesMediaContainer,
@@ -140,6 +157,24 @@ export namespace GetDevicesMediaContainer$ {
   export type Outbound = GetDevicesMediaContainer$Outbound;
 }
 
+export function getDevicesMediaContainerToJSON(
+  getDevicesMediaContainer: GetDevicesMediaContainer,
+): string {
+  return JSON.stringify(
+    GetDevicesMediaContainer$outboundSchema.parse(getDevicesMediaContainer),
+  );
+}
+
+export function getDevicesMediaContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<GetDevicesMediaContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetDevicesMediaContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetDevicesMediaContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetDevicesResponseBody$inboundSchema: z.ZodType<
   GetDevicesResponseBody,
@@ -186,6 +221,24 @@ export namespace GetDevicesResponseBody$ {
   export type Outbound = GetDevicesResponseBody$Outbound;
 }
 
+export function getDevicesResponseBodyToJSON(
+  getDevicesResponseBody: GetDevicesResponseBody,
+): string {
+  return JSON.stringify(
+    GetDevicesResponseBody$outboundSchema.parse(getDevicesResponseBody),
+  );
+}
+
+export function getDevicesResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetDevicesResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetDevicesResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetDevicesResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetDevicesResponse$inboundSchema: z.ZodType<
   GetDevicesResponse,
@@ -244,3 +297,21 @@ export namespace GetDevicesResponse$ {
   /** @deprecated use `GetDevicesResponse$Outbound` instead. */
   export type Outbound = GetDevicesResponse$Outbound;
 }
+
+export function getDevicesResponseToJSON(
+  getDevicesResponse: GetDevicesResponse,
+): string {
+  return JSON.stringify(
+    GetDevicesResponse$outboundSchema.parse(getDevicesResponse),
+  );
+}
+
+export function getDevicesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetDevicesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetDevicesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetDevicesResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getfilehash.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type GetFileHashRequest = {
   /**
@@ -70,6 +73,24 @@ export namespace GetFileHashRequest$ {
   export type Outbound = GetFileHashRequest$Outbound;
 }
 
+export function getFileHashRequestToJSON(
+  getFileHashRequest: GetFileHashRequest,
+): string {
+  return JSON.stringify(
+    GetFileHashRequest$outboundSchema.parse(getFileHashRequest),
+  );
+}
+
+export function getFileHashRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetFileHashRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetFileHashRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetFileHashRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetFileHashResponse$inboundSchema: z.ZodType<
   GetFileHashResponse,
@@ -125,3 +146,21 @@ export namespace GetFileHashResponse$ {
   /** @deprecated use `GetFileHashResponse$Outbound` instead. */
   export type Outbound = GetFileHashResponse$Outbound;
 }
+
+export function getFileHashResponseToJSON(
+  getFileHashResponse: GetFileHashResponse,
+): string {
+  return JSON.stringify(
+    GetFileHashResponse$outboundSchema.parse(getFileHashResponse),
+  );
+}
+
+export function getFileHashResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetFileHashResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetFileHashResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetFileHashResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getgeodata.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const GetGeoDataServerList = [
   "https://plex.tv/api/v2",
@@ -162,6 +165,24 @@ export namespace GetGeoDataGeoData$ {
   export type Outbound = GetGeoDataGeoData$Outbound;
 }
 
+export function getGeoDataGeoDataToJSON(
+  getGeoDataGeoData: GetGeoDataGeoData,
+): string {
+  return JSON.stringify(
+    GetGeoDataGeoData$outboundSchema.parse(getGeoDataGeoData),
+  );
+}
+
+export function getGeoDataGeoDataFromJSON(
+  jsonString: string,
+): SafeParseResult<GetGeoDataGeoData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetGeoDataGeoData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetGeoDataGeoData' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetGeoDataResponse$inboundSchema: z.ZodType<
   GetGeoDataResponse,
@@ -222,3 +243,21 @@ export namespace GetGeoDataResponse$ {
   /** @deprecated use `GetGeoDataResponse$Outbound` instead. */
   export type Outbound = GetGeoDataResponse$Outbound;
 }
+
+export function getGeoDataResponseToJSON(
+  getGeoDataResponse: GetGeoDataResponse,
+): string {
+  return JSON.stringify(
+    GetGeoDataResponse$outboundSchema.parse(getGeoDataResponse),
+  );
+}
+
+export function getGeoDataResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetGeoDataResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetGeoDataResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetGeoDataResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getglobalhubs.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * Only return hubs which are "transient", meaning those which are prone to changing after media playback or addition (e.g. On Deck, or Recently Added).
@@ -151,6 +154,24 @@ export namespace GetGlobalHubsRequest$ {
   export type Outbound = GetGlobalHubsRequest$Outbound;
 }
 
+export function getGlobalHubsRequestToJSON(
+  getGlobalHubsRequest: GetGlobalHubsRequest,
+): string {
+  return JSON.stringify(
+    GetGlobalHubsRequest$outboundSchema.parse(getGlobalHubsRequest),
+  );
+}
+
+export function getGlobalHubsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetGlobalHubsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetGlobalHubsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetGlobalHubsRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetGlobalHubsMetadata$inboundSchema: z.ZodType<
   GetGlobalHubsMetadata,
@@ -235,6 +256,24 @@ export namespace GetGlobalHubsMetadata$ {
   export type Outbound = GetGlobalHubsMetadata$Outbound;
 }
 
+export function getGlobalHubsMetadataToJSON(
+  getGlobalHubsMetadata: GetGlobalHubsMetadata,
+): string {
+  return JSON.stringify(
+    GetGlobalHubsMetadata$outboundSchema.parse(getGlobalHubsMetadata),
+  );
+}
+
+export function getGlobalHubsMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<GetGlobalHubsMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetGlobalHubsMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetGlobalHubsMetadata' from JSON`,
+  );
+}
+
 /** @internal */
 export const Hub$inboundSchema: z.ZodType<Hub, z.ZodTypeDef, unknown> = z
   .object({
@@ -305,6 +344,20 @@ export namespace Hub$ {
   export type Outbound = Hub$Outbound;
 }
 
+export function hubToJSON(hub: Hub): string {
+  return JSON.stringify(Hub$outboundSchema.parse(hub));
+}
+
+export function hubFromJSON(
+  jsonString: string,
+): SafeParseResult<Hub, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Hub$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Hub' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetGlobalHubsMediaContainer$inboundSchema: z.ZodType<
   GetGlobalHubsMediaContainer,
@@ -358,6 +411,26 @@ export namespace GetGlobalHubsMediaContainer$ {
   export type Outbound = GetGlobalHubsMediaContainer$Outbound;
 }
 
+export function getGlobalHubsMediaContainerToJSON(
+  getGlobalHubsMediaContainer: GetGlobalHubsMediaContainer,
+): string {
+  return JSON.stringify(
+    GetGlobalHubsMediaContainer$outboundSchema.parse(
+      getGlobalHubsMediaContainer,
+    ),
+  );
+}
+
+export function getGlobalHubsMediaContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<GetGlobalHubsMediaContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetGlobalHubsMediaContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetGlobalHubsMediaContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetGlobalHubsResponseBody$inboundSchema: z.ZodType<
   GetGlobalHubsResponseBody,
@@ -404,6 +477,24 @@ export namespace GetGlobalHubsResponseBody$ {
   export type Outbound = GetGlobalHubsResponseBody$Outbound;
 }
 
+export function getGlobalHubsResponseBodyToJSON(
+  getGlobalHubsResponseBody: GetGlobalHubsResponseBody,
+): string {
+  return JSON.stringify(
+    GetGlobalHubsResponseBody$outboundSchema.parse(getGlobalHubsResponseBody),
+  );
+}
+
+export function getGlobalHubsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetGlobalHubsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetGlobalHubsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetGlobalHubsResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetGlobalHubsResponse$inboundSchema: z.ZodType<
   GetGlobalHubsResponse,
@@ -462,3 +553,21 @@ export namespace GetGlobalHubsResponse$ {
   /** @deprecated use `GetGlobalHubsResponse$Outbound` instead. */
   export type Outbound = GetGlobalHubsResponse$Outbound;
 }
+
+export function getGlobalHubsResponseToJSON(
+  getGlobalHubsResponse: GetGlobalHubsResponse,
+): string {
+  return JSON.stringify(
+    GetGlobalHubsResponse$outboundSchema.parse(getGlobalHubsResponse),
+  );
+}
+
+export function getGlobalHubsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetGlobalHubsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetGlobalHubsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetGlobalHubsResponse' from JSON`,
+  );
+}

src/sdk/models/operations/gethomedata.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * Home Data
@@ -87,6 +90,24 @@ export namespace GetHomeDataResponseBody$ {
   export type Outbound = GetHomeDataResponseBody$Outbound;
 }
 
+export function getHomeDataResponseBodyToJSON(
+  getHomeDataResponseBody: GetHomeDataResponseBody,
+): string {
+  return JSON.stringify(
+    GetHomeDataResponseBody$outboundSchema.parse(getHomeDataResponseBody),
+  );
+}
+
+export function getHomeDataResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetHomeDataResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetHomeDataResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetHomeDataResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetHomeDataResponse$inboundSchema: z.ZodType<
   GetHomeDataResponse,
@@ -145,3 +166,21 @@ export namespace GetHomeDataResponse$ {
   /** @deprecated use `GetHomeDataResponse$Outbound` instead. */
   export type Outbound = GetHomeDataResponse$Outbound;
 }
+
+export function getHomeDataResponseToJSON(
+  getHomeDataResponse: GetHomeDataResponse,
+): string {
+  return JSON.stringify(
+    GetHomeDataResponse$outboundSchema.parse(getHomeDataResponse),
+  );
+}
+
+export function getHomeDataResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetHomeDataResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetHomeDataResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetHomeDataResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getlibrarydetails.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * Whether or not to include details for a section (types, filters, and sorts).
@@ -189,6 +192,24 @@ export namespace GetLibraryDetailsRequest$ {
   export type Outbound = GetLibraryDetailsRequest$Outbound;
 }
 
+export function getLibraryDetailsRequestToJSON(
+  getLibraryDetailsRequest: GetLibraryDetailsRequest,
+): string {
+  return JSON.stringify(
+    GetLibraryDetailsRequest$outboundSchema.parse(getLibraryDetailsRequest),
+  );
+}
+
+export function getLibraryDetailsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryDetailsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryDetailsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryDetailsRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryDetailsDirectory$inboundSchema: z.ZodType<
   GetLibraryDetailsDirectory,
@@ -237,6 +258,24 @@ export namespace GetLibraryDetailsDirectory$ {
   export type Outbound = GetLibraryDetailsDirectory$Outbound;
 }
 
+export function getLibraryDetailsDirectoryToJSON(
+  getLibraryDetailsDirectory: GetLibraryDetailsDirectory,
+): string {
+  return JSON.stringify(
+    GetLibraryDetailsDirectory$outboundSchema.parse(getLibraryDetailsDirectory),
+  );
+}
+
+export function getLibraryDetailsDirectoryFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryDetailsDirectory, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryDetailsDirectory$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryDetailsDirectory' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryDetailsFilter$inboundSchema: z.ZodType<
   GetLibraryDetailsFilter,
@@ -285,6 +324,24 @@ export namespace GetLibraryDetailsFilter$ {
   export type Outbound = GetLibraryDetailsFilter$Outbound;
 }
 
+export function getLibraryDetailsFilterToJSON(
+  getLibraryDetailsFilter: GetLibraryDetailsFilter,
+): string {
+  return JSON.stringify(
+    GetLibraryDetailsFilter$outboundSchema.parse(getLibraryDetailsFilter),
+  );
+}
+
+export function getLibraryDetailsFilterFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryDetailsFilter, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryDetailsFilter$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryDetailsFilter' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryDetailsSort$inboundSchema: z.ZodType<
   GetLibraryDetailsSort,
@@ -336,6 +393,24 @@ export namespace GetLibraryDetailsSort$ {
   export type Outbound = GetLibraryDetailsSort$Outbound;
 }
 
+export function getLibraryDetailsSortToJSON(
+  getLibraryDetailsSort: GetLibraryDetailsSort,
+): string {
+  return JSON.stringify(
+    GetLibraryDetailsSort$outboundSchema.parse(getLibraryDetailsSort),
+  );
+}
+
+export function getLibraryDetailsSortFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryDetailsSort, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryDetailsSort$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryDetailsSort' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryDetailsField$inboundSchema: z.ZodType<
   GetLibraryDetailsField,
@@ -381,6 +456,24 @@ export namespace GetLibraryDetailsField$ {
   export type Outbound = GetLibraryDetailsField$Outbound;
 }
 
+export function getLibraryDetailsFieldToJSON(
+  getLibraryDetailsField: GetLibraryDetailsField,
+): string {
+  return JSON.stringify(
+    GetLibraryDetailsField$outboundSchema.parse(getLibraryDetailsField),
+  );
+}
+
+export function getLibraryDetailsFieldFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryDetailsField, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryDetailsField$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryDetailsField' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryDetailsType$inboundSchema: z.ZodType<
   GetLibraryDetailsType,
@@ -450,6 +543,24 @@ export namespace GetLibraryDetailsType$ {
   export type Outbound = GetLibraryDetailsType$Outbound;
 }
 
+export function getLibraryDetailsTypeToJSON(
+  getLibraryDetailsType: GetLibraryDetailsType,
+): string {
+  return JSON.stringify(
+    GetLibraryDetailsType$outboundSchema.parse(getLibraryDetailsType),
+  );
+}
+
+export function getLibraryDetailsTypeFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryDetailsType, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryDetailsType$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryDetailsType' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryDetailsOperator$inboundSchema: z.ZodType<
   GetLibraryDetailsOperator,
@@ -489,6 +600,24 @@ export namespace GetLibraryDetailsOperator$ {
   export type Outbound = GetLibraryDetailsOperator$Outbound;
 }
 
+export function getLibraryDetailsOperatorToJSON(
+  getLibraryDetailsOperator: GetLibraryDetailsOperator,
+): string {
+  return JSON.stringify(
+    GetLibraryDetailsOperator$outboundSchema.parse(getLibraryDetailsOperator),
+  );
+}
+
+export function getLibraryDetailsOperatorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryDetailsOperator, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryDetailsOperator$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryDetailsOperator' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryDetailsFieldType$inboundSchema: z.ZodType<
   GetLibraryDetailsFieldType,
@@ -538,6 +667,24 @@ export namespace GetLibraryDetailsFieldType$ {
   export type Outbound = GetLibraryDetailsFieldType$Outbound;
 }
 
+export function getLibraryDetailsFieldTypeToJSON(
+  getLibraryDetailsFieldType: GetLibraryDetailsFieldType,
+): string {
+  return JSON.stringify(
+    GetLibraryDetailsFieldType$outboundSchema.parse(getLibraryDetailsFieldType),
+  );
+}
+
+export function getLibraryDetailsFieldTypeFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryDetailsFieldType, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryDetailsFieldType$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryDetailsFieldType' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryDetailsMediaContainer$inboundSchema: z.ZodType<
   GetLibraryDetailsMediaContainer,
@@ -632,6 +779,26 @@ export namespace GetLibraryDetailsMediaContainer$ {
   export type Outbound = GetLibraryDetailsMediaContainer$Outbound;
 }
 
+export function getLibraryDetailsMediaContainerToJSON(
+  getLibraryDetailsMediaContainer: GetLibraryDetailsMediaContainer,
+): string {
+  return JSON.stringify(
+    GetLibraryDetailsMediaContainer$outboundSchema.parse(
+      getLibraryDetailsMediaContainer,
+    ),
+  );
+}
+
+export function getLibraryDetailsMediaContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryDetailsMediaContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryDetailsMediaContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryDetailsMediaContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryDetailsResponseBody$inboundSchema: z.ZodType<
   GetLibraryDetailsResponseBody,
@@ -678,6 +845,26 @@ export namespace GetLibraryDetailsResponseBody$ {
   export type Outbound = GetLibraryDetailsResponseBody$Outbound;
 }
 
+export function getLibraryDetailsResponseBodyToJSON(
+  getLibraryDetailsResponseBody: GetLibraryDetailsResponseBody,
+): string {
+  return JSON.stringify(
+    GetLibraryDetailsResponseBody$outboundSchema.parse(
+      getLibraryDetailsResponseBody,
+    ),
+  );
+}
+
+export function getLibraryDetailsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryDetailsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryDetailsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryDetailsResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryDetailsResponse$inboundSchema: z.ZodType<
   GetLibraryDetailsResponse,
@@ -736,3 +923,21 @@ export namespace GetLibraryDetailsResponse$ {
   /** @deprecated use `GetLibraryDetailsResponse$Outbound` instead. */
   export type Outbound = GetLibraryDetailsResponse$Outbound;
 }
+
+export function getLibraryDetailsResponseToJSON(
+  getLibraryDetailsResponse: GetLibraryDetailsResponse,
+): string {
+  return JSON.stringify(
+    GetLibraryDetailsResponse$outboundSchema.parse(getLibraryDetailsResponse),
+  );
+}
+
+export function getLibraryDetailsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryDetailsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryDetailsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryDetailsResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getlibraryhubs.ts

@@ -4,7 +4,10 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
 import { RFCDate } from "../../types/rfcdate.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * Only return hubs which are "transient", meaning those which are prone to changing after media playback or addition (e.g. On Deck, or Recently Added).
@@ -233,6 +236,24 @@ export namespace GetLibraryHubsRequest$ {
   export type Outbound = GetLibraryHubsRequest$Outbound;
 }
 
+export function getLibraryHubsRequestToJSON(
+  getLibraryHubsRequest: GetLibraryHubsRequest,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsRequest$outboundSchema.parse(getLibraryHubsRequest),
+  );
+}
+
+export function getLibraryHubsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsPart$inboundSchema: z.ZodType<
   GetLibraryHubsPart,
@@ -296,6 +317,24 @@ export namespace GetLibraryHubsPart$ {
   export type Outbound = GetLibraryHubsPart$Outbound;
 }
 
+export function getLibraryHubsPartToJSON(
+  getLibraryHubsPart: GetLibraryHubsPart,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsPart$outboundSchema.parse(getLibraryHubsPart),
+  );
+}
+
+export function getLibraryHubsPartFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsPart' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsMedia$inboundSchema: z.ZodType<
   GetLibraryHubsMedia,
@@ -388,6 +427,24 @@ export namespace GetLibraryHubsMedia$ {
   export type Outbound = GetLibraryHubsMedia$Outbound;
 }
 
+export function getLibraryHubsMediaToJSON(
+  getLibraryHubsMedia: GetLibraryHubsMedia,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsMedia$outboundSchema.parse(getLibraryHubsMedia),
+  );
+}
+
+export function getLibraryHubsMediaFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsMedia, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsMedia$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsMedia' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsGenre$inboundSchema: z.ZodType<
   GetLibraryHubsGenre,
@@ -424,6 +481,24 @@ export namespace GetLibraryHubsGenre$ {
   export type Outbound = GetLibraryHubsGenre$Outbound;
 }
 
+export function getLibraryHubsGenreToJSON(
+  getLibraryHubsGenre: GetLibraryHubsGenre,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsGenre$outboundSchema.parse(getLibraryHubsGenre),
+  );
+}
+
+export function getLibraryHubsGenreFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsGenre, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsGenre$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsGenre' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsCountry$inboundSchema: z.ZodType<
   GetLibraryHubsCountry,
@@ -460,6 +535,24 @@ export namespace GetLibraryHubsCountry$ {
   export type Outbound = GetLibraryHubsCountry$Outbound;
 }
 
+export function getLibraryHubsCountryToJSON(
+  getLibraryHubsCountry: GetLibraryHubsCountry,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsCountry$outboundSchema.parse(getLibraryHubsCountry),
+  );
+}
+
+export function getLibraryHubsCountryFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsCountry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsCountry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsCountry' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsDirector$inboundSchema: z.ZodType<
   GetLibraryHubsDirector,
@@ -496,6 +589,24 @@ export namespace GetLibraryHubsDirector$ {
   export type Outbound = GetLibraryHubsDirector$Outbound;
 }
 
+export function getLibraryHubsDirectorToJSON(
+  getLibraryHubsDirector: GetLibraryHubsDirector,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsDirector$outboundSchema.parse(getLibraryHubsDirector),
+  );
+}
+
+export function getLibraryHubsDirectorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsDirector, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsDirector$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsDirector' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsRole$inboundSchema: z.ZodType<
   GetLibraryHubsRole,
@@ -532,6 +643,24 @@ export namespace GetLibraryHubsRole$ {
   export type Outbound = GetLibraryHubsRole$Outbound;
 }
 
+export function getLibraryHubsRoleToJSON(
+  getLibraryHubsRole: GetLibraryHubsRole,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsRole$outboundSchema.parse(getLibraryHubsRole),
+  );
+}
+
+export function getLibraryHubsRoleFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsRole, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsRole$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsRole' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsWriter$inboundSchema: z.ZodType<
   GetLibraryHubsWriter,
@@ -568,6 +697,24 @@ export namespace GetLibraryHubsWriter$ {
   export type Outbound = GetLibraryHubsWriter$Outbound;
 }
 
+export function getLibraryHubsWriterToJSON(
+  getLibraryHubsWriter: GetLibraryHubsWriter,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsWriter$outboundSchema.parse(getLibraryHubsWriter),
+  );
+}
+
+export function getLibraryHubsWriterFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsWriter, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsWriter$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsWriter' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsMetadata$inboundSchema: z.ZodType<
   GetLibraryHubsMetadata,
@@ -726,6 +873,24 @@ export namespace GetLibraryHubsMetadata$ {
   export type Outbound = GetLibraryHubsMetadata$Outbound;
 }
 
+export function getLibraryHubsMetadataToJSON(
+  getLibraryHubsMetadata: GetLibraryHubsMetadata,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsMetadata$outboundSchema.parse(getLibraryHubsMetadata),
+  );
+}
+
+export function getLibraryHubsMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsMetadata' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsHub$inboundSchema: z.ZodType<
   GetLibraryHubsHub,
@@ -805,6 +970,24 @@ export namespace GetLibraryHubsHub$ {
   export type Outbound = GetLibraryHubsHub$Outbound;
 }
 
+export function getLibraryHubsHubToJSON(
+  getLibraryHubsHub: GetLibraryHubsHub,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsHub$outboundSchema.parse(getLibraryHubsHub),
+  );
+}
+
+export function getLibraryHubsHubFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsHub, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsHub$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsHub' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsMediaContainer$inboundSchema: z.ZodType<
   GetLibraryHubsMediaContainer,
@@ -867,6 +1050,26 @@ export namespace GetLibraryHubsMediaContainer$ {
   export type Outbound = GetLibraryHubsMediaContainer$Outbound;
 }
 
+export function getLibraryHubsMediaContainerToJSON(
+  getLibraryHubsMediaContainer: GetLibraryHubsMediaContainer,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsMediaContainer$outboundSchema.parse(
+      getLibraryHubsMediaContainer,
+    ),
+  );
+}
+
+export function getLibraryHubsMediaContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsMediaContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsMediaContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsMediaContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsResponseBody$inboundSchema: z.ZodType<
   GetLibraryHubsResponseBody,
@@ -913,6 +1116,24 @@ export namespace GetLibraryHubsResponseBody$ {
   export type Outbound = GetLibraryHubsResponseBody$Outbound;
 }
 
+export function getLibraryHubsResponseBodyToJSON(
+  getLibraryHubsResponseBody: GetLibraryHubsResponseBody,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsResponseBody$outboundSchema.parse(getLibraryHubsResponseBody),
+  );
+}
+
+export function getLibraryHubsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryHubsResponse$inboundSchema: z.ZodType<
   GetLibraryHubsResponse,
@@ -971,3 +1192,21 @@ export namespace GetLibraryHubsResponse$ {
   /** @deprecated use `GetLibraryHubsResponse$Outbound` instead. */
   export type Outbound = GetLibraryHubsResponse$Outbound;
 }
+
+export function getLibraryHubsResponseToJSON(
+  getLibraryHubsResponse: GetLibraryHubsResponse,
+): string {
+  return JSON.stringify(
+    GetLibraryHubsResponse$outboundSchema.parse(getLibraryHubsResponse),
+  );
+}
+
+export function getLibraryHubsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryHubsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryHubsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryHubsResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getlibraryitems.ts

@@ -4,7 +4,10 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
 import { RFCDate } from "../../types/rfcdate.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * A key representing a specific tag within the section.
@@ -29,6 +32,7 @@ export enum Tag {
   Resolution = "resolution",
   FirstCharacter = "firstCharacter",
   Folder = "folder",
+  Albums = "albums",
 }
 
 /**
@@ -57,6 +61,8 @@ export enum GetLibraryItemsQueryParamType {
   Season = 3,
   Episode = 4,
   Audio = 8,
+  Album = 9,
+  Track = 10,
 }
 
 /**
@@ -221,16 +227,16 @@ export enum GetLibraryItemsFlattenSeasons {
  * @remarks
  * None = Library default,
  * tmdbAiring = The Movie Database (Aired),
- * aired = TheTVDB (Aired),
- * dvd = TheTVDB (DVD),
- * absolute = TheTVDB (Absolute)).
+ * tvdbAiring = TheTVDB (Aired),
+ * tvdbDvd = TheTVDB (DVD),
+ * tvdbAbsolute = TheTVDB (Absolute)).
  */
 export enum GetLibraryItemsShowOrdering {
   None = "None",
   TmdbAiring = "tmdbAiring",
-  Aired = "aired",
-  Dvd = "dvd",
-  Absolute = "absolute",
+  TvdbAiring = "tvdbAiring",
+  TvdbDvd = "tvdbDvd",
+  TvdbAbsolute = "tvdbAbsolute",
 }
 
 export enum GetLibraryItemsOptimizedForStreaming {
@@ -561,9 +567,9 @@ export type GetLibraryItemsMetadata = {
    * @remarks
    * None = Library default,
    * tmdbAiring = The Movie Database (Aired),
-   * aired = TheTVDB (Aired),
-   * dvd = TheTVDB (DVD),
-   * absolute = TheTVDB (Absolute)).
+   * tvdbAiring = TheTVDB (Aired),
+   * tvdbDvd = TheTVDB (DVD),
+   * tvdbAbsolute = TheTVDB (Absolute)).
    */
   showOrdering?: GetLibraryItemsShowOrdering | undefined;
   thumb?: string | undefined;
@@ -939,6 +945,24 @@ export namespace GetLibraryItemsRequest$ {
   export type Outbound = GetLibraryItemsRequest$Outbound;
 }
 
+export function getLibraryItemsRequestToJSON(
+  getLibraryItemsRequest: GetLibraryItemsRequest,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsRequest$outboundSchema.parse(getLibraryItemsRequest),
+  );
+}
+
+export function getLibraryItemsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsFilter$inboundSchema: z.ZodType<
   GetLibraryItemsFilter,
@@ -987,6 +1011,24 @@ export namespace GetLibraryItemsFilter$ {
   export type Outbound = GetLibraryItemsFilter$Outbound;
 }
 
+export function getLibraryItemsFilterToJSON(
+  getLibraryItemsFilter: GetLibraryItemsFilter,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsFilter$outboundSchema.parse(getLibraryItemsFilter),
+  );
+}
+
+export function getLibraryItemsFilterFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsFilter, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsFilter$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsFilter' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsActiveDirection$inboundSchema: z.ZodNativeEnum<
   typeof GetLibraryItemsActiveDirection
@@ -1094,6 +1136,24 @@ export namespace GetLibraryItemsSort$ {
   export type Outbound = GetLibraryItemsSort$Outbound;
 }
 
+export function getLibraryItemsSortToJSON(
+  getLibraryItemsSort: GetLibraryItemsSort,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsSort$outboundSchema.parse(getLibraryItemsSort),
+  );
+}
+
+export function getLibraryItemsSortFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsSort, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsSort$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsSort' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsField$inboundSchema: z.ZodType<
   GetLibraryItemsField,
@@ -1139,6 +1199,24 @@ export namespace GetLibraryItemsField$ {
   export type Outbound = GetLibraryItemsField$Outbound;
 }
 
+export function getLibraryItemsFieldToJSON(
+  getLibraryItemsField: GetLibraryItemsField,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsField$outboundSchema.parse(getLibraryItemsField),
+  );
+}
+
+export function getLibraryItemsFieldFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsField, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsField$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsField' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsType$inboundSchema: z.ZodType<
   GetLibraryItemsType,
@@ -1206,6 +1284,24 @@ export namespace GetLibraryItemsType$ {
   export type Outbound = GetLibraryItemsType$Outbound;
 }
 
+export function getLibraryItemsTypeToJSON(
+  getLibraryItemsType: GetLibraryItemsType,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsType$outboundSchema.parse(getLibraryItemsType),
+  );
+}
+
+export function getLibraryItemsTypeFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsType, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsType$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsType' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsOperator$inboundSchema: z.ZodType<
   GetLibraryItemsOperator,
@@ -1245,6 +1341,24 @@ export namespace GetLibraryItemsOperator$ {
   export type Outbound = GetLibraryItemsOperator$Outbound;
 }
 
+export function getLibraryItemsOperatorToJSON(
+  getLibraryItemsOperator: GetLibraryItemsOperator,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsOperator$outboundSchema.parse(getLibraryItemsOperator),
+  );
+}
+
+export function getLibraryItemsOperatorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsOperator, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsOperator$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsOperator' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsFieldType$inboundSchema: z.ZodType<
   GetLibraryItemsFieldType,
@@ -1292,6 +1406,24 @@ export namespace GetLibraryItemsFieldType$ {
   export type Outbound = GetLibraryItemsFieldType$Outbound;
 }
 
+export function getLibraryItemsFieldTypeToJSON(
+  getLibraryItemsFieldType: GetLibraryItemsFieldType,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsFieldType$outboundSchema.parse(getLibraryItemsFieldType),
+  );
+}
+
+export function getLibraryItemsFieldTypeFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsFieldType, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsFieldType$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsFieldType' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsLibraryType$inboundSchema: z.ZodNativeEnum<
   typeof GetLibraryItemsLibraryType
@@ -1547,6 +1679,24 @@ export namespace GetLibraryItemsStream$ {
   export type Outbound = GetLibraryItemsStream$Outbound;
 }
 
+export function getLibraryItemsStreamToJSON(
+  getLibraryItemsStream: GetLibraryItemsStream,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsStream$outboundSchema.parse(getLibraryItemsStream),
+  );
+}
+
+export function getLibraryItemsStreamFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsStream, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsStream$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsStream' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsPart$inboundSchema: z.ZodType<
   GetLibraryItemsPart,
@@ -1632,6 +1782,24 @@ export namespace GetLibraryItemsPart$ {
   export type Outbound = GetLibraryItemsPart$Outbound;
 }
 
+export function getLibraryItemsPartToJSON(
+  getLibraryItemsPart: GetLibraryItemsPart,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsPart$outboundSchema.parse(getLibraryItemsPart),
+  );
+}
+
+export function getLibraryItemsPartFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsPart' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsMedia$inboundSchema: z.ZodType<
   GetLibraryItemsMedia,
@@ -1728,6 +1896,24 @@ export namespace GetLibraryItemsMedia$ {
   export type Outbound = GetLibraryItemsMedia$Outbound;
 }
 
+export function getLibraryItemsMediaToJSON(
+  getLibraryItemsMedia: GetLibraryItemsMedia,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsMedia$outboundSchema.parse(getLibraryItemsMedia),
+  );
+}
+
+export function getLibraryItemsMediaFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsMedia, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsMedia$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsMedia' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsGenre$inboundSchema: z.ZodType<
   GetLibraryItemsGenre,
@@ -1764,6 +1950,24 @@ export namespace GetLibraryItemsGenre$ {
   export type Outbound = GetLibraryItemsGenre$Outbound;
 }
 
+export function getLibraryItemsGenreToJSON(
+  getLibraryItemsGenre: GetLibraryItemsGenre,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsGenre$outboundSchema.parse(getLibraryItemsGenre),
+  );
+}
+
+export function getLibraryItemsGenreFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsGenre, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsGenre$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsGenre' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsCountry$inboundSchema: z.ZodType<
   GetLibraryItemsCountry,
@@ -1800,6 +2004,24 @@ export namespace GetLibraryItemsCountry$ {
   export type Outbound = GetLibraryItemsCountry$Outbound;
 }
 
+export function getLibraryItemsCountryToJSON(
+  getLibraryItemsCountry: GetLibraryItemsCountry,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsCountry$outboundSchema.parse(getLibraryItemsCountry),
+  );
+}
+
+export function getLibraryItemsCountryFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsCountry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsCountry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsCountry' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsDirector$inboundSchema: z.ZodType<
   GetLibraryItemsDirector,
@@ -1836,6 +2058,24 @@ export namespace GetLibraryItemsDirector$ {
   export type Outbound = GetLibraryItemsDirector$Outbound;
 }
 
+export function getLibraryItemsDirectorToJSON(
+  getLibraryItemsDirector: GetLibraryItemsDirector,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsDirector$outboundSchema.parse(getLibraryItemsDirector),
+  );
+}
+
+export function getLibraryItemsDirectorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsDirector, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsDirector$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsDirector' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsWriter$inboundSchema: z.ZodType<
   GetLibraryItemsWriter,
@@ -1872,6 +2112,24 @@ export namespace GetLibraryItemsWriter$ {
   export type Outbound = GetLibraryItemsWriter$Outbound;
 }
 
+export function getLibraryItemsWriterToJSON(
+  getLibraryItemsWriter: GetLibraryItemsWriter,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsWriter$outboundSchema.parse(getLibraryItemsWriter),
+  );
+}
+
+export function getLibraryItemsWriterFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsWriter, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsWriter$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsWriter' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsCollection$inboundSchema: z.ZodType<
   GetLibraryItemsCollection,
@@ -1908,6 +2166,24 @@ export namespace GetLibraryItemsCollection$ {
   export type Outbound = GetLibraryItemsCollection$Outbound;
 }
 
+export function getLibraryItemsCollectionToJSON(
+  getLibraryItemsCollection: GetLibraryItemsCollection,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsCollection$outboundSchema.parse(getLibraryItemsCollection),
+  );
+}
+
+export function getLibraryItemsCollectionFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsCollection, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsCollection$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsCollection' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsRole$inboundSchema: z.ZodType<
   GetLibraryItemsRole,
@@ -1959,6 +2235,24 @@ export namespace GetLibraryItemsRole$ {
   export type Outbound = GetLibraryItemsRole$Outbound;
 }
 
+export function getLibraryItemsRoleToJSON(
+  getLibraryItemsRole: GetLibraryItemsRole,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsRole$outboundSchema.parse(getLibraryItemsRole),
+  );
+}
+
+export function getLibraryItemsRoleFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsRole, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsRole$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsRole' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsLocation$inboundSchema: z.ZodType<
   GetLibraryItemsLocation,
@@ -1995,6 +2289,24 @@ export namespace GetLibraryItemsLocation$ {
   export type Outbound = GetLibraryItemsLocation$Outbound;
 }
 
+export function getLibraryItemsLocationToJSON(
+  getLibraryItemsLocation: GetLibraryItemsLocation,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsLocation$outboundSchema.parse(getLibraryItemsLocation),
+  );
+}
+
+export function getLibraryItemsLocationFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsLocation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsLocation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsLocation' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsMediaGuid$inboundSchema: z.ZodType<
   GetLibraryItemsMediaGuid,
@@ -2031,6 +2343,24 @@ export namespace GetLibraryItemsMediaGuid$ {
   export type Outbound = GetLibraryItemsMediaGuid$Outbound;
 }
 
+export function getLibraryItemsMediaGuidToJSON(
+  getLibraryItemsMediaGuid: GetLibraryItemsMediaGuid,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsMediaGuid$outboundSchema.parse(getLibraryItemsMediaGuid),
+  );
+}
+
+export function getLibraryItemsMediaGuidFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsMediaGuid, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsMediaGuid$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsMediaGuid' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsUltraBlurColors$inboundSchema: z.ZodType<
   GetLibraryItemsUltraBlurColors,
@@ -2076,6 +2406,26 @@ export namespace GetLibraryItemsUltraBlurColors$ {
   export type Outbound = GetLibraryItemsUltraBlurColors$Outbound;
 }
 
+export function getLibraryItemsUltraBlurColorsToJSON(
+  getLibraryItemsUltraBlurColors: GetLibraryItemsUltraBlurColors,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsUltraBlurColors$outboundSchema.parse(
+      getLibraryItemsUltraBlurColors,
+    ),
+  );
+}
+
+export function getLibraryItemsUltraBlurColorsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsUltraBlurColors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsUltraBlurColors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsUltraBlurColors' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsMetaDataRating$inboundSchema: z.ZodType<
   GetLibraryItemsMetaDataRating,
@@ -2118,6 +2468,26 @@ export namespace GetLibraryItemsMetaDataRating$ {
   export type Outbound = GetLibraryItemsMetaDataRating$Outbound;
 }
 
+export function getLibraryItemsMetaDataRatingToJSON(
+  getLibraryItemsMetaDataRating: GetLibraryItemsMetaDataRating,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsMetaDataRating$outboundSchema.parse(
+      getLibraryItemsMetaDataRating,
+    ),
+  );
+}
+
+export function getLibraryItemsMetaDataRatingFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsMetaDataRating, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsMetaDataRating$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsMetaDataRating' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsLibraryResponse200Type$inboundSchema:
   z.ZodNativeEnum<typeof GetLibraryItemsLibraryResponse200Type> = z.nativeEnum(
@@ -2184,6 +2554,24 @@ export namespace GetLibraryItemsImage$ {
   export type Outbound = GetLibraryItemsImage$Outbound;
 }
 
+export function getLibraryItemsImageToJSON(
+  getLibraryItemsImage: GetLibraryItemsImage,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsImage$outboundSchema.parse(getLibraryItemsImage),
+  );
+}
+
+export function getLibraryItemsImageFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsImage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsImage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsImage' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsMetadata$inboundSchema: z.ZodType<
   GetLibraryItemsMetadata,
@@ -2490,6 +2878,24 @@ export namespace GetLibraryItemsMetadata$ {
   export type Outbound = GetLibraryItemsMetadata$Outbound;
 }
 
+export function getLibraryItemsMetadataToJSON(
+  getLibraryItemsMetadata: GetLibraryItemsMetadata,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsMetadata$outboundSchema.parse(getLibraryItemsMetadata),
+  );
+}
+
+export function getLibraryItemsMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsMetadata' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsLibraryFilter$inboundSchema: z.ZodType<
   GetLibraryItemsLibraryFilter,
@@ -2538,6 +2944,26 @@ export namespace GetLibraryItemsLibraryFilter$ {
   export type Outbound = GetLibraryItemsLibraryFilter$Outbound;
 }
 
+export function getLibraryItemsLibraryFilterToJSON(
+  getLibraryItemsLibraryFilter: GetLibraryItemsLibraryFilter,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsLibraryFilter$outboundSchema.parse(
+      getLibraryItemsLibraryFilter,
+    ),
+  );
+}
+
+export function getLibraryItemsLibraryFilterFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsLibraryFilter, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsLibraryFilter$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsLibraryFilter' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsLibraryActiveDirection$inboundSchema:
   z.ZodNativeEnum<typeof GetLibraryItemsLibraryActiveDirection> = z.nativeEnum(
@@ -2649,6 +3075,24 @@ export namespace GetLibraryItemsLibrarySort$ {
   export type Outbound = GetLibraryItemsLibrarySort$Outbound;
 }
 
+export function getLibraryItemsLibrarySortToJSON(
+  getLibraryItemsLibrarySort: GetLibraryItemsLibrarySort,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsLibrarySort$outboundSchema.parse(getLibraryItemsLibrarySort),
+  );
+}
+
+export function getLibraryItemsLibrarySortFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsLibrarySort, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsLibrarySort$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsLibrarySort' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsLibraryField$inboundSchema: z.ZodType<
   GetLibraryItemsLibraryField,
@@ -2694,6 +3138,26 @@ export namespace GetLibraryItemsLibraryField$ {
   export type Outbound = GetLibraryItemsLibraryField$Outbound;
 }
 
+export function getLibraryItemsLibraryFieldToJSON(
+  getLibraryItemsLibraryField: GetLibraryItemsLibraryField,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsLibraryField$outboundSchema.parse(
+      getLibraryItemsLibraryField,
+    ),
+  );
+}
+
+export function getLibraryItemsLibraryFieldFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsLibraryField, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsLibraryField$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsLibraryField' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsLibraryResponseType$inboundSchema: z.ZodType<
   GetLibraryItemsLibraryResponseType,
@@ -2767,6 +3231,27 @@ export namespace GetLibraryItemsLibraryResponseType$ {
   export type Outbound = GetLibraryItemsLibraryResponseType$Outbound;
 }
 
+export function getLibraryItemsLibraryResponseTypeToJSON(
+  getLibraryItemsLibraryResponseType: GetLibraryItemsLibraryResponseType,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsLibraryResponseType$outboundSchema.parse(
+      getLibraryItemsLibraryResponseType,
+    ),
+  );
+}
+
+export function getLibraryItemsLibraryResponseTypeFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsLibraryResponseType, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetLibraryItemsLibraryResponseType$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsLibraryResponseType' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsLibraryOperator$inboundSchema: z.ZodType<
   GetLibraryItemsLibraryOperator,
@@ -2806,6 +3291,26 @@ export namespace GetLibraryItemsLibraryOperator$ {
   export type Outbound = GetLibraryItemsLibraryOperator$Outbound;
 }
 
+export function getLibraryItemsLibraryOperatorToJSON(
+  getLibraryItemsLibraryOperator: GetLibraryItemsLibraryOperator,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsLibraryOperator$outboundSchema.parse(
+      getLibraryItemsLibraryOperator,
+    ),
+  );
+}
+
+export function getLibraryItemsLibraryOperatorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsLibraryOperator, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsLibraryOperator$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsLibraryOperator' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsLibraryFieldType$inboundSchema: z.ZodType<
   GetLibraryItemsLibraryFieldType,
@@ -2855,6 +3360,26 @@ export namespace GetLibraryItemsLibraryFieldType$ {
   export type Outbound = GetLibraryItemsLibraryFieldType$Outbound;
 }
 
+export function getLibraryItemsLibraryFieldTypeToJSON(
+  getLibraryItemsLibraryFieldType: GetLibraryItemsLibraryFieldType,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsLibraryFieldType$outboundSchema.parse(
+      getLibraryItemsLibraryFieldType,
+    ),
+  );
+}
+
+export function getLibraryItemsLibraryFieldTypeFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsLibraryFieldType, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsLibraryFieldType$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsLibraryFieldType' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsMeta$inboundSchema: z.ZodType<
   GetLibraryItemsMeta,
@@ -2910,6 +3435,24 @@ export namespace GetLibraryItemsMeta$ {
   export type Outbound = GetLibraryItemsMeta$Outbound;
 }
 
+export function getLibraryItemsMetaToJSON(
+  getLibraryItemsMeta: GetLibraryItemsMeta,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsMeta$outboundSchema.parse(getLibraryItemsMeta),
+  );
+}
+
+export function getLibraryItemsMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsMeta' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsMediaContainer$inboundSchema: z.ZodType<
   GetLibraryItemsMediaContainer,
@@ -3030,6 +3573,26 @@ export namespace GetLibraryItemsMediaContainer$ {
   export type Outbound = GetLibraryItemsMediaContainer$Outbound;
 }
 
+export function getLibraryItemsMediaContainerToJSON(
+  getLibraryItemsMediaContainer: GetLibraryItemsMediaContainer,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsMediaContainer$outboundSchema.parse(
+      getLibraryItemsMediaContainer,
+    ),
+  );
+}
+
+export function getLibraryItemsMediaContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsMediaContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsMediaContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsMediaContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsResponseBody$inboundSchema: z.ZodType<
   GetLibraryItemsResponseBody,
@@ -3076,6 +3639,26 @@ export namespace GetLibraryItemsResponseBody$ {
   export type Outbound = GetLibraryItemsResponseBody$Outbound;
 }
 
+export function getLibraryItemsResponseBodyToJSON(
+  getLibraryItemsResponseBody: GetLibraryItemsResponseBody,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsResponseBody$outboundSchema.parse(
+      getLibraryItemsResponseBody,
+    ),
+  );
+}
+
+export function getLibraryItemsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetLibraryItemsResponse$inboundSchema: z.ZodType<
   GetLibraryItemsResponse,
@@ -3134,3 +3717,21 @@ export namespace GetLibraryItemsResponse$ {
   /** @deprecated use `GetLibraryItemsResponse$Outbound` instead. */
   export type Outbound = GetLibraryItemsResponse$Outbound;
 }
+
+export function getLibraryItemsResponseToJSON(
+  getLibraryItemsResponse: GetLibraryItemsResponse,
+): string {
+  return JSON.stringify(
+    GetLibraryItemsResponse$outboundSchema.parse(getLibraryItemsResponse),
+  );
+}
+
+export function getLibraryItemsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetLibraryItemsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetLibraryItemsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetLibraryItemsResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getmediaproviders.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type GetMediaProvidersRequest = {
   /**
@@ -178,6 +181,24 @@ export namespace GetMediaProvidersRequest$ {
   export type Outbound = GetMediaProvidersRequest$Outbound;
 }
 
+export function getMediaProvidersRequestToJSON(
+  getMediaProvidersRequest: GetMediaProvidersRequest,
+): string {
+  return JSON.stringify(
+    GetMediaProvidersRequest$outboundSchema.parse(getMediaProvidersRequest),
+  );
+}
+
+export function getMediaProvidersRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMediaProvidersRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMediaProvidersRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMediaProvidersRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const Pivot$inboundSchema: z.ZodType<Pivot, z.ZodTypeDef, unknown> = z
   .object({
@@ -226,6 +247,20 @@ export namespace Pivot$ {
   export type Outbound = Pivot$Outbound;
 }
 
+export function pivotToJSON(pivot: Pivot): string {
+  return JSON.stringify(Pivot$outboundSchema.parse(pivot));
+}
+
+export function pivotFromJSON(
+  jsonString: string,
+): SafeParseResult<Pivot, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Pivot$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Pivot' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMediaProvidersDirectory$inboundSchema: z.ZodType<
   GetMediaProvidersDirectory,
@@ -309,6 +344,24 @@ export namespace GetMediaProvidersDirectory$ {
   export type Outbound = GetMediaProvidersDirectory$Outbound;
 }
 
+export function getMediaProvidersDirectoryToJSON(
+  getMediaProvidersDirectory: GetMediaProvidersDirectory,
+): string {
+  return JSON.stringify(
+    GetMediaProvidersDirectory$outboundSchema.parse(getMediaProvidersDirectory),
+  );
+}
+
+export function getMediaProvidersDirectoryFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMediaProvidersDirectory, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMediaProvidersDirectory$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMediaProvidersDirectory' from JSON`,
+  );
+}
+
 /** @internal */
 export const Action$inboundSchema: z.ZodType<Action, z.ZodTypeDef, unknown> = z
   .object({
@@ -345,6 +398,20 @@ export namespace Action$ {
   export type Outbound = Action$Outbound;
 }
 
+export function actionToJSON(action: Action): string {
+  return JSON.stringify(Action$outboundSchema.parse(action));
+}
+
+export function actionFromJSON(
+  jsonString: string,
+): SafeParseResult<Action, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Action$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Action' from JSON`,
+  );
+}
+
 /** @internal */
 export const Feature$inboundSchema: z.ZodType<Feature, z.ZodTypeDef, unknown> =
   z.object({
@@ -408,6 +475,20 @@ export namespace Feature$ {
   export type Outbound = Feature$Outbound;
 }
 
+export function featureToJSON(feature: Feature): string {
+  return JSON.stringify(Feature$outboundSchema.parse(feature));
+}
+
+export function featureFromJSON(
+  jsonString: string,
+): SafeParseResult<Feature, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Feature$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Feature' from JSON`,
+  );
+}
+
 /** @internal */
 export const MediaProvider$inboundSchema: z.ZodType<
   MediaProvider,
@@ -464,6 +545,20 @@ export namespace MediaProvider$ {
   export type Outbound = MediaProvider$Outbound;
 }
 
+export function mediaProviderToJSON(mediaProvider: MediaProvider): string {
+  return JSON.stringify(MediaProvider$outboundSchema.parse(mediaProvider));
+}
+
+export function mediaProviderFromJSON(
+  jsonString: string,
+): SafeParseResult<MediaProvider, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MediaProvider$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MediaProvider' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMediaProvidersMediaContainer$inboundSchema: z.ZodType<
   GetMediaProvidersMediaContainer,
@@ -637,6 +732,26 @@ export namespace GetMediaProvidersMediaContainer$ {
   export type Outbound = GetMediaProvidersMediaContainer$Outbound;
 }
 
+export function getMediaProvidersMediaContainerToJSON(
+  getMediaProvidersMediaContainer: GetMediaProvidersMediaContainer,
+): string {
+  return JSON.stringify(
+    GetMediaProvidersMediaContainer$outboundSchema.parse(
+      getMediaProvidersMediaContainer,
+    ),
+  );
+}
+
+export function getMediaProvidersMediaContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMediaProvidersMediaContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMediaProvidersMediaContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMediaProvidersMediaContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMediaProvidersResponseBody$inboundSchema: z.ZodType<
   GetMediaProvidersResponseBody,
@@ -683,6 +798,26 @@ export namespace GetMediaProvidersResponseBody$ {
   export type Outbound = GetMediaProvidersResponseBody$Outbound;
 }
 
+export function getMediaProvidersResponseBodyToJSON(
+  getMediaProvidersResponseBody: GetMediaProvidersResponseBody,
+): string {
+  return JSON.stringify(
+    GetMediaProvidersResponseBody$outboundSchema.parse(
+      getMediaProvidersResponseBody,
+    ),
+  );
+}
+
+export function getMediaProvidersResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMediaProvidersResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMediaProvidersResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMediaProvidersResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMediaProvidersResponse$inboundSchema: z.ZodType<
   GetMediaProvidersResponse,
@@ -741,3 +876,21 @@ export namespace GetMediaProvidersResponse$ {
   /** @deprecated use `GetMediaProvidersResponse$Outbound` instead. */
   export type Outbound = GetMediaProvidersResponse$Outbound;
 }
+
+export function getMediaProvidersResponseToJSON(
+  getMediaProvidersResponse: GetMediaProvidersResponse,
+): string {
+  return JSON.stringify(
+    GetMediaProvidersResponse$outboundSchema.parse(getMediaProvidersResponse),
+  );
+}
+
+export function getMediaProvidersResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMediaProvidersResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMediaProvidersResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMediaProvidersResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getmetadatabyratingkey.ts

@@ -4,7 +4,10 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
 import { RFCDate } from "../../types/rfcdate.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type GetMetaDataByRatingKeyRequest = {
   /**
@@ -147,6 +150,26 @@ export type GetMetaDataByRatingKeyMetadata = {
   librarySectionTitle?: string | undefined;
   librarySectionID?: number | undefined;
   librarySectionKey?: string | undefined;
+  /**
+   * The name of the album artist for the track when audio, and the name of the TV show for the episode when video.
+   */
+  grandparentTitle?: string | undefined;
+  /**
+   * The name of the album for the track when audio, and the name of the season for the episode when TV show.
+   */
+  parentTitle?: string | undefined;
+  /**
+   * The orginal untranslated name of the media item when non-english.
+   */
+  originalTitle?: string | undefined;
+  /**
+   * The index starting from 0 of this media item in the MetaData array.
+   */
+  index?: number | undefined;
+  /**
+   * The parent index starting from 0 of this media item in the parent MetaData array.
+   */
+  parentIndex?: number | undefined;
   contentRating?: string | undefined;
   summary?: string | undefined;
   rating?: number | undefined;
@@ -247,6 +270,26 @@ export namespace GetMetaDataByRatingKeyRequest$ {
   export type Outbound = GetMetaDataByRatingKeyRequest$Outbound;
 }
 
+export function getMetaDataByRatingKeyRequestToJSON(
+  getMetaDataByRatingKeyRequest: GetMetaDataByRatingKeyRequest,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyRequest$outboundSchema.parse(
+      getMetaDataByRatingKeyRequest,
+    ),
+  );
+}
+
+export function getMetaDataByRatingKeyRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetaDataByRatingKeyRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyStream$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyStream,
@@ -376,6 +419,26 @@ export namespace GetMetaDataByRatingKeyStream$ {
   export type Outbound = GetMetaDataByRatingKeyStream$Outbound;
 }
 
+export function getMetaDataByRatingKeyStreamToJSON(
+  getMetaDataByRatingKeyStream: GetMetaDataByRatingKeyStream,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyStream$outboundSchema.parse(
+      getMetaDataByRatingKeyStream,
+    ),
+  );
+}
+
+export function getMetaDataByRatingKeyStreamFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyStream, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetaDataByRatingKeyStream$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyStream' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyPart$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyPart,
@@ -452,6 +515,24 @@ export namespace GetMetaDataByRatingKeyPart$ {
   export type Outbound = GetMetaDataByRatingKeyPart$Outbound;
 }
 
+export function getMetaDataByRatingKeyPartToJSON(
+  getMetaDataByRatingKeyPart: GetMetaDataByRatingKeyPart,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyPart$outboundSchema.parse(getMetaDataByRatingKeyPart),
+  );
+}
+
+export function getMetaDataByRatingKeyPartFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetaDataByRatingKeyPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyPart' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyMedia$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyMedia,
@@ -546,6 +627,26 @@ export namespace GetMetaDataByRatingKeyMedia$ {
   export type Outbound = GetMetaDataByRatingKeyMedia$Outbound;
 }
 
+export function getMetaDataByRatingKeyMediaToJSON(
+  getMetaDataByRatingKeyMedia: GetMetaDataByRatingKeyMedia,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyMedia$outboundSchema.parse(
+      getMetaDataByRatingKeyMedia,
+    ),
+  );
+}
+
+export function getMetaDataByRatingKeyMediaFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyMedia, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetaDataByRatingKeyMedia$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyMedia' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyGenre$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyGenre,
@@ -588,6 +689,26 @@ export namespace GetMetaDataByRatingKeyGenre$ {
   export type Outbound = GetMetaDataByRatingKeyGenre$Outbound;
 }
 
+export function getMetaDataByRatingKeyGenreToJSON(
+  getMetaDataByRatingKeyGenre: GetMetaDataByRatingKeyGenre,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyGenre$outboundSchema.parse(
+      getMetaDataByRatingKeyGenre,
+    ),
+  );
+}
+
+export function getMetaDataByRatingKeyGenreFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyGenre, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetaDataByRatingKeyGenre$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyGenre' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyCountry$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyCountry,
@@ -630,6 +751,26 @@ export namespace GetMetaDataByRatingKeyCountry$ {
   export type Outbound = GetMetaDataByRatingKeyCountry$Outbound;
 }
 
+export function getMetaDataByRatingKeyCountryToJSON(
+  getMetaDataByRatingKeyCountry: GetMetaDataByRatingKeyCountry,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyCountry$outboundSchema.parse(
+      getMetaDataByRatingKeyCountry,
+    ),
+  );
+}
+
+export function getMetaDataByRatingKeyCountryFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyCountry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetaDataByRatingKeyCountry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyCountry' from JSON`,
+  );
+}
+
 /** @internal */
 export const Guids$inboundSchema: z.ZodType<Guids, z.ZodTypeDef, unknown> = z
   .object({
@@ -663,6 +804,20 @@ export namespace Guids$ {
   export type Outbound = Guids$Outbound;
 }
 
+export function guidsToJSON(guids: Guids): string {
+  return JSON.stringify(Guids$outboundSchema.parse(guids));
+}
+
+export function guidsFromJSON(
+  jsonString: string,
+): SafeParseResult<Guids, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Guids$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Guids' from JSON`,
+  );
+}
+
 /** @internal */
 export const Ratings$inboundSchema: z.ZodType<Ratings, z.ZodTypeDef, unknown> =
   z.object({
@@ -702,6 +857,20 @@ export namespace Ratings$ {
   export type Outbound = Ratings$Outbound;
 }
 
+export function ratingsToJSON(ratings: Ratings): string {
+  return JSON.stringify(Ratings$outboundSchema.parse(ratings));
+}
+
+export function ratingsFromJSON(
+  jsonString: string,
+): SafeParseResult<Ratings, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Ratings$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Ratings' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyDirector$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyDirector,
@@ -750,6 +919,26 @@ export namespace GetMetaDataByRatingKeyDirector$ {
   export type Outbound = GetMetaDataByRatingKeyDirector$Outbound;
 }
 
+export function getMetaDataByRatingKeyDirectorToJSON(
+  getMetaDataByRatingKeyDirector: GetMetaDataByRatingKeyDirector,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyDirector$outboundSchema.parse(
+      getMetaDataByRatingKeyDirector,
+    ),
+  );
+}
+
+export function getMetaDataByRatingKeyDirectorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyDirector, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetaDataByRatingKeyDirector$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyDirector' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyWriter$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyWriter,
@@ -798,6 +987,26 @@ export namespace GetMetaDataByRatingKeyWriter$ {
   export type Outbound = GetMetaDataByRatingKeyWriter$Outbound;
 }
 
+export function getMetaDataByRatingKeyWriterToJSON(
+  getMetaDataByRatingKeyWriter: GetMetaDataByRatingKeyWriter,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyWriter$outboundSchema.parse(
+      getMetaDataByRatingKeyWriter,
+    ),
+  );
+}
+
+export function getMetaDataByRatingKeyWriterFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyWriter, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetaDataByRatingKeyWriter$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyWriter' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyRole$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyRole,
@@ -849,6 +1058,24 @@ export namespace GetMetaDataByRatingKeyRole$ {
   export type Outbound = GetMetaDataByRatingKeyRole$Outbound;
 }
 
+export function getMetaDataByRatingKeyRoleToJSON(
+  getMetaDataByRatingKeyRole: GetMetaDataByRatingKeyRole,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyRole$outboundSchema.parse(getMetaDataByRatingKeyRole),
+  );
+}
+
+export function getMetaDataByRatingKeyRoleFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyRole, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetaDataByRatingKeyRole$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyRole' from JSON`,
+  );
+}
+
 /** @internal */
 export const Producer$inboundSchema: z.ZodType<
   Producer,
@@ -897,6 +1124,20 @@ export namespace Producer$ {
   export type Outbound = Producer$Outbound;
 }
 
+export function producerToJSON(producer: Producer): string {
+  return JSON.stringify(Producer$outboundSchema.parse(producer));
+}
+
+export function producerFromJSON(
+  jsonString: string,
+): SafeParseResult<Producer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Producer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Producer' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyMetadata$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyMetadata,
@@ -912,6 +1153,11 @@ export const GetMetaDataByRatingKeyMetadata$inboundSchema: z.ZodType<
   librarySectionTitle: z.string().optional(),
   librarySectionID: z.number().int().optional(),
   librarySectionKey: z.string().optional(),
+  grandparentTitle: z.string().optional(),
+  parentTitle: z.string().optional(),
+  originalTitle: z.string().optional(),
+  index: z.number().int().optional(),
+  parentIndex: z.number().int().optional(),
   contentRating: z.string().optional(),
   summary: z.string().optional(),
   rating: z.number().optional(),
@@ -967,6 +1213,11 @@ export type GetMetaDataByRatingKeyMetadata$Outbound = {
   librarySectionTitle?: string | undefined;
   librarySectionID?: number | undefined;
   librarySectionKey?: string | undefined;
+  grandparentTitle?: string | undefined;
+  parentTitle?: string | undefined;
+  originalTitle?: string | undefined;
+  index?: number | undefined;
+  parentIndex?: number | undefined;
   contentRating?: string | undefined;
   summary?: string | undefined;
   rating?: number | undefined;
@@ -1008,6 +1259,11 @@ export const GetMetaDataByRatingKeyMetadata$outboundSchema: z.ZodType<
   librarySectionTitle: z.string().optional(),
   librarySectionID: z.number().int().optional(),
   librarySectionKey: z.string().optional(),
+  grandparentTitle: z.string().optional(),
+  parentTitle: z.string().optional(),
+  originalTitle: z.string().optional(),
+  index: z.number().int().optional(),
+  parentIndex: z.number().int().optional(),
   contentRating: z.string().optional(),
   summary: z.string().optional(),
   rating: z.number().optional(),
@@ -1066,6 +1322,26 @@ export namespace GetMetaDataByRatingKeyMetadata$ {
   export type Outbound = GetMetaDataByRatingKeyMetadata$Outbound;
 }
 
+export function getMetaDataByRatingKeyMetadataToJSON(
+  getMetaDataByRatingKeyMetadata: GetMetaDataByRatingKeyMetadata,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyMetadata$outboundSchema.parse(
+      getMetaDataByRatingKeyMetadata,
+    ),
+  );
+}
+
+export function getMetaDataByRatingKeyMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetaDataByRatingKeyMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyMetadata' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyMediaContainer$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyMediaContainer,
@@ -1138,6 +1414,27 @@ export namespace GetMetaDataByRatingKeyMediaContainer$ {
   export type Outbound = GetMetaDataByRatingKeyMediaContainer$Outbound;
 }
 
+export function getMetaDataByRatingKeyMediaContainerToJSON(
+  getMetaDataByRatingKeyMediaContainer: GetMetaDataByRatingKeyMediaContainer,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyMediaContainer$outboundSchema.parse(
+      getMetaDataByRatingKeyMediaContainer,
+    ),
+  );
+}
+
+export function getMetaDataByRatingKeyMediaContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyMediaContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetMetaDataByRatingKeyMediaContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyMediaContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyResponseBody$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyResponseBody,
@@ -1187,6 +1484,27 @@ export namespace GetMetaDataByRatingKeyResponseBody$ {
   export type Outbound = GetMetaDataByRatingKeyResponseBody$Outbound;
 }
 
+export function getMetaDataByRatingKeyResponseBodyToJSON(
+  getMetaDataByRatingKeyResponseBody: GetMetaDataByRatingKeyResponseBody,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyResponseBody$outboundSchema.parse(
+      getMetaDataByRatingKeyResponseBody,
+    ),
+  );
+}
+
+export function getMetaDataByRatingKeyResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetMetaDataByRatingKeyResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetaDataByRatingKeyResponse$inboundSchema: z.ZodType<
   GetMetaDataByRatingKeyResponse,
@@ -1247,3 +1565,23 @@ export namespace GetMetaDataByRatingKeyResponse$ {
   /** @deprecated use `GetMetaDataByRatingKeyResponse$Outbound` instead. */
   export type Outbound = GetMetaDataByRatingKeyResponse$Outbound;
 }
+
+export function getMetaDataByRatingKeyResponseToJSON(
+  getMetaDataByRatingKeyResponse: GetMetaDataByRatingKeyResponse,
+): string {
+  return JSON.stringify(
+    GetMetaDataByRatingKeyResponse$outboundSchema.parse(
+      getMetaDataByRatingKeyResponse,
+    ),
+  );
+}
+
+export function getMetaDataByRatingKeyResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetaDataByRatingKeyResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetaDataByRatingKeyResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetaDataByRatingKeyResponse' from JSON`,
+  );
+}

src/sdk/models/operations/getmetadatachildren.ts

@@ -4,6 +4,9 @@
 
 import * as z from "zod";
 import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type GetMetadataChildrenRequest = {
   /**
@@ -147,6 +150,24 @@ export namespace GetMetadataChildrenRequest$ {
   export type Outbound = GetMetadataChildrenRequest$Outbound;
 }
 
+export function getMetadataChildrenRequestToJSON(
+  getMetadataChildrenRequest: GetMetadataChildrenRequest,
+): string {
+  return JSON.stringify(
+    GetMetadataChildrenRequest$outboundSchema.parse(getMetadataChildrenRequest),
+  );
+}
+
+export function getMetadataChildrenRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetadataChildrenRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetadataChildrenRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetadataChildrenRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetadataChildrenDirectory$inboundSchema: z.ZodType<
   GetMetadataChildrenDirectory,
@@ -195,6 +216,26 @@ export namespace GetMetadataChildrenDirectory$ {
   export type Outbound = GetMetadataChildrenDirectory$Outbound;
 }
 
+export function getMetadataChildrenDirectoryToJSON(
+  getMetadataChildrenDirectory: GetMetadataChildrenDirectory,
+): string {
+  return JSON.stringify(
+    GetMetadataChildrenDirectory$outboundSchema.parse(
+      getMetadataChildrenDirectory,
+    ),
+  );
+}
+
+export function getMetadataChildrenDirectoryFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetadataChildrenDirectory, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetadataChildrenDirectory$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetadataChildrenDirectory' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetadataChildrenMetadata$inboundSchema: z.ZodType<
   GetMetadataChildrenMetadata,
@@ -309,6 +350,26 @@ export namespace GetMetadataChildrenMetadata$ {
   export type Outbound = GetMetadataChildrenMetadata$Outbound;
 }
 
+export function getMetadataChildrenMetadataToJSON(
+  getMetadataChildrenMetadata: GetMetadataChildrenMetadata,
+): string {
+  return JSON.stringify(
+    GetMetadataChildrenMetadata$outboundSchema.parse(
+      getMetadataChildrenMetadata,
+    ),
+  );
+}
+
+export function getMetadataChildrenMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetadataChildrenMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetadataChildrenMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetadataChildrenMetadata' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetadataChildrenMediaContainer$inboundSchema: z.ZodType<
   GetMetadataChildrenMediaContainer,
@@ -426,6 +487,26 @@ export namespace GetMetadataChildrenMediaContainer$ {
   export type Outbound = GetMetadataChildrenMediaContainer$Outbound;
 }
 
+export function getMetadataChildrenMediaContainerToJSON(
+  getMetadataChildrenMediaContainer: GetMetadataChildrenMediaContainer,
+): string {
+  return JSON.stringify(
+    GetMetadataChildrenMediaContainer$outboundSchema.parse(
+      getMetadataChildrenMediaContainer,
+    ),
+  );
+}
+
+export function getMetadataChildrenMediaContainerFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetadataChildrenMediaContainer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetadataChildrenMediaContainer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetadataChildrenMediaContainer' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetadataChildrenResponseBody$inboundSchema: z.ZodType<
   GetMetadataChildrenResponseBody,
@@ -472,6 +553,26 @@ export namespace GetMetadataChildrenResponseBody$ {
   export type Outbound = GetMetadataChildrenResponseBody$Outbound;
 }
 
+export function getMetadataChildrenResponseBodyToJSON(
+  getMetadataChildrenResponseBody: GetMetadataChildrenResponseBody,
+): string {
+  return JSON.stringify(
+    GetMetadataChildrenResponseBody$outboundSchema.parse(
+      getMetadataChildrenResponseBody,
+    ),
+  );
+}
+
+export function getMetadataChildrenResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetadataChildrenResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetadataChildrenResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetadataChildrenResponseBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetMetadataChildrenResponse$inboundSchema: z.ZodType<
   GetMetadataChildrenResponse,
@@ -532,3 +633,23 @@ export namespace GetMetadataChildrenResponse$ {
   /** @deprecated use `GetMetadataChildrenResponse$Outbound` instead. */
   export type Outbound = GetMetadataChildrenResponse$Outbound;
 }
+
+export function getMetadataChildrenResponseToJSON(
+  getMetadataChildrenResponse: GetMetadataChildrenResponse,
+): string {
+  return JSON.stringify(
+    GetMetadataChildrenResponse$outboundSchema.parse(
+      getMetadataChildrenResponse,
+    ),
+  );
+}
+
+export function getMetadataChildrenResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetMetadataChildrenResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetMetadataChildrenResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetMetadataChildrenResponse' from JSON`,
+  );
+}