@vercel/sdk 14.0.0-canary.6 → 14.0.0-canary.7

package/src/models/components/authuser.ts

@@ -3,7 +3,10 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const Reason = {
   SubscriptionCanceled: "SUBSCRIPTION_CANCELED",
@@ -148,6 +151,14 @@ export type ResourceConfig = {
    * An object containing infomation related to the amount of platform resources may be allocated to the User account.
    */
   cronJobsPerProject?: number | undefined;
+  /**
+   * An object containing infomation related to the amount of platform resources may be allocated to the User account.
+   */
+  microfrontendGroupsPerTeam?: number | undefined;
+  /**
+   * An object containing infomation related to the amount of platform resources may be allocated to the User account.
+   */
+  microfrontendProjectsPerGroup?: number | undefined;
 };
 
 export const ViewPreference = {
@@ -471,6 +482,20 @@ export namespace SoftBlock$ {
   export type Outbound = SoftBlock$Outbound;
 }
 
+export function softBlockToJSON(softBlock: SoftBlock): string {
+  return JSON.stringify(SoftBlock$outboundSchema.parse(softBlock));
+}
+
+export function softBlockFromJSON(
+  jsonString: string,
+): SafeParseResult<SoftBlock, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SoftBlock$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SoftBlock' from JSON`,
+  );
+}
+
 /** @internal */
 export const Billing$inboundSchema: z.ZodType<Billing, z.ZodTypeDef, unknown> =
   z.object({});
@@ -498,6 +523,20 @@ export namespace Billing$ {
   export type Outbound = Billing$Outbound;
 }
 
+export function billingToJSON(billing: Billing): string {
+  return JSON.stringify(Billing$outboundSchema.parse(billing));
+}
+
+export function billingFromJSON(
+  jsonString: string,
+): SafeParseResult<Billing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Billing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Billing' from JSON`,
+  );
+}
+
 /** @internal */
 export const ResourceConfig$inboundSchema: z.ZodType<
   ResourceConfig,
@@ -521,6 +560,8 @@ export const ResourceConfig$inboundSchema: z.ZodType<
   integrationStores: z.number().optional(),
   cronJobs: z.number().optional(),
   cronJobsPerProject: z.number().optional(),
+  microfrontendGroupsPerTeam: z.number().optional(),
+  microfrontendProjectsPerGroup: z.number().optional(),
 });
 
 /** @internal */
@@ -542,6 +583,8 @@ export type ResourceConfig$Outbound = {
   integrationStores?: number | undefined;
   cronJobs?: number | undefined;
   cronJobsPerProject?: number | undefined;
+  microfrontendGroupsPerTeam?: number | undefined;
+  microfrontendProjectsPerGroup?: number | undefined;
 };
 
 /** @internal */
@@ -567,6 +610,8 @@ export const ResourceConfig$outboundSchema: z.ZodType<
   integrationStores: z.number().optional(),
   cronJobs: z.number().optional(),
   cronJobsPerProject: z.number().optional(),
+  microfrontendGroupsPerTeam: z.number().optional(),
+  microfrontendProjectsPerGroup: z.number().optional(),
 });
 
 /**
@@ -582,6 +627,20 @@ export namespace ResourceConfig$ {
   export type Outbound = ResourceConfig$Outbound;
 }
 
+export function resourceConfigToJSON(resourceConfig: ResourceConfig): string {
+  return JSON.stringify(ResourceConfig$outboundSchema.parse(resourceConfig));
+}
+
+export function resourceConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<ResourceConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResourceConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResourceConfig' from JSON`,
+  );
+}
+
 /** @internal */
 export const ViewPreference$inboundSchema: z.ZodNativeEnum<
   typeof ViewPreference
@@ -690,6 +749,24 @@ export namespace ActiveDashboardViews$ {
   export type Outbound = ActiveDashboardViews$Outbound;
 }
 
+export function activeDashboardViewsToJSON(
+  activeDashboardViews: ActiveDashboardViews,
+): string {
+  return JSON.stringify(
+    ActiveDashboardViews$outboundSchema.parse(activeDashboardViews),
+  );
+}
+
+export function activeDashboardViewsFromJSON(
+  jsonString: string,
+): SafeParseResult<ActiveDashboardViews, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ActiveDashboardViews$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ActiveDashboardViews' from JSON`,
+  );
+}
+
 /** @internal */
 export const ImportFlowGitNamespace$inboundSchema: z.ZodType<
   ImportFlowGitNamespace,
@@ -720,6 +797,24 @@ export namespace ImportFlowGitNamespace$ {
   export type Outbound = ImportFlowGitNamespace$Outbound;
 }
 
+export function importFlowGitNamespaceToJSON(
+  importFlowGitNamespace: ImportFlowGitNamespace,
+): string {
+  return JSON.stringify(
+    ImportFlowGitNamespace$outboundSchema.parse(importFlowGitNamespace),
+  );
+}
+
+export function importFlowGitNamespaceFromJSON(
+  jsonString: string,
+): SafeParseResult<ImportFlowGitNamespace, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ImportFlowGitNamespace$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ImportFlowGitNamespace' from JSON`,
+  );
+}
+
 /** @internal */
 export const ImportFlowGitNamespaceId$inboundSchema: z.ZodType<
   ImportFlowGitNamespaceId,
@@ -750,6 +845,24 @@ export namespace ImportFlowGitNamespaceId$ {
   export type Outbound = ImportFlowGitNamespaceId$Outbound;
 }
 
+export function importFlowGitNamespaceIdToJSON(
+  importFlowGitNamespaceId: ImportFlowGitNamespaceId,
+): string {
+  return JSON.stringify(
+    ImportFlowGitNamespaceId$outboundSchema.parse(importFlowGitNamespaceId),
+  );
+}
+
+export function importFlowGitNamespaceIdFromJSON(
+  jsonString: string,
+): SafeParseResult<ImportFlowGitNamespaceId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ImportFlowGitNamespaceId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ImportFlowGitNamespaceId' from JSON`,
+  );
+}
+
 /** @internal */
 export const ImportFlowGitProvider$inboundSchema: z.ZodNativeEnum<
   typeof ImportFlowGitProvider
@@ -801,6 +914,20 @@ export namespace GitNamespaceId$ {
   export type Outbound = GitNamespaceId$Outbound;
 }
 
+export function gitNamespaceIdToJSON(gitNamespaceId: GitNamespaceId): string {
+  return JSON.stringify(GitNamespaceId$outboundSchema.parse(gitNamespaceId));
+}
+
+export function gitNamespaceIdFromJSON(
+  jsonString: string,
+): SafeParseResult<GitNamespaceId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitNamespaceId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitNamespaceId' from JSON`,
+  );
+}
+
 /** @internal */
 export const PreferredScopesAndGitNamespaces$inboundSchema: z.ZodType<
   PreferredScopesAndGitNamespaces,
@@ -840,6 +967,26 @@ export namespace PreferredScopesAndGitNamespaces$ {
   export type Outbound = PreferredScopesAndGitNamespaces$Outbound;
 }
 
+export function preferredScopesAndGitNamespacesToJSON(
+  preferredScopesAndGitNamespaces: PreferredScopesAndGitNamespaces,
+): string {
+  return JSON.stringify(
+    PreferredScopesAndGitNamespaces$outboundSchema.parse(
+      preferredScopesAndGitNamespaces,
+    ),
+  );
+}
+
+export function preferredScopesAndGitNamespacesFromJSON(
+  jsonString: string,
+): SafeParseResult<PreferredScopesAndGitNamespaces, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PreferredScopesAndGitNamespaces$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PreferredScopesAndGitNamespaces' from JSON`,
+  );
+}
+
 /** @internal */
 export const Dismissals$inboundSchema: z.ZodType<
   Dismissals,
@@ -879,6 +1026,20 @@ export namespace Dismissals$ {
   export type Outbound = Dismissals$Outbound;
 }
 
+export function dismissalsToJSON(dismissals: Dismissals): string {
+  return JSON.stringify(Dismissals$outboundSchema.parse(dismissals));
+}
+
+export function dismissalsFromJSON(
+  jsonString: string,
+): SafeParseResult<Dismissals, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Dismissals$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Dismissals' from JSON`,
+  );
+}
+
 /** @internal */
 export const DismissedToasts$inboundSchema: z.ZodType<
   DismissedToasts,
@@ -918,6 +1079,22 @@ export namespace DismissedToasts$ {
   export type Outbound = DismissedToasts$Outbound;
 }
 
+export function dismissedToastsToJSON(
+  dismissedToasts: DismissedToasts,
+): string {
+  return JSON.stringify(DismissedToasts$outboundSchema.parse(dismissedToasts));
+}
+
+export function dismissedToastsFromJSON(
+  jsonString: string,
+): SafeParseResult<DismissedToasts, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DismissedToasts$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DismissedToasts' from JSON`,
+  );
+}
+
 /** @internal */
 export const Two$inboundSchema: z.ZodType<Two, z.ZodTypeDef, unknown> = z
   .object({
@@ -954,6 +1131,20 @@ export namespace Two$ {
   export type Outbound = Two$Outbound;
 }
 
+export function twoToJSON(two: Two): string {
+  return JSON.stringify(Two$outboundSchema.parse(two));
+}
+
+export function twoFromJSON(
+  jsonString: string,
+): SafeParseResult<Two, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Two$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Two' from JSON`,
+  );
+}
+
 /** @internal */
 export const One$inboundSchema: z.ZodType<One, z.ZodTypeDef, unknown> = z
   .object({
@@ -990,6 +1181,20 @@ export namespace One$ {
   export type Outbound = One$Outbound;
 }
 
+export function oneToJSON(one: One): string {
+  return JSON.stringify(One$outboundSchema.parse(one));
+}
+
+export function oneFromJSON(
+  jsonString: string,
+): SafeParseResult<One, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => One$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'One' from JSON`,
+  );
+}
+
 /** @internal */
 export const FavoriteProjectsAndSpaces$inboundSchema: z.ZodType<
   FavoriteProjectsAndSpaces,
@@ -1023,6 +1228,24 @@ export namespace FavoriteProjectsAndSpaces$ {
   export type Outbound = FavoriteProjectsAndSpaces$Outbound;
 }
 
+export function favoriteProjectsAndSpacesToJSON(
+  favoriteProjectsAndSpaces: FavoriteProjectsAndSpaces,
+): string {
+  return JSON.stringify(
+    FavoriteProjectsAndSpaces$outboundSchema.parse(favoriteProjectsAndSpaces),
+  );
+}
+
+export function favoriteProjectsAndSpacesFromJSON(
+  jsonString: string,
+): SafeParseResult<FavoriteProjectsAndSpaces, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FavoriteProjectsAndSpaces$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FavoriteProjectsAndSpaces' from JSON`,
+  );
+}
+
 /** @internal */
 export const RemoteCaching$inboundSchema: z.ZodType<
   RemoteCaching,
@@ -1059,6 +1282,20 @@ export namespace RemoteCaching$ {
   export type Outbound = RemoteCaching$Outbound;
 }
 
+export function remoteCachingToJSON(remoteCaching: RemoteCaching): string {
+  return JSON.stringify(RemoteCaching$outboundSchema.parse(remoteCaching));
+}
+
+export function remoteCachingFromJSON(
+  jsonString: string,
+): SafeParseResult<RemoteCaching, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RemoteCaching$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RemoteCaching' from JSON`,
+  );
+}
+
 /** @internal */
 export const DataCache$inboundSchema: z.ZodType<
   DataCache,
@@ -1095,6 +1332,20 @@ export namespace DataCache$ {
   export type Outbound = DataCache$Outbound;
 }
 
+export function dataCacheToJSON(dataCache: DataCache): string {
+  return JSON.stringify(DataCache$outboundSchema.parse(dataCache));
+}
+
+export function dataCacheFromJSON(
+  jsonString: string,
+): SafeParseResult<DataCache, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DataCache$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DataCache' from JSON`,
+  );
+}
+
 /** @internal */
 export const WebAnalytics$inboundSchema: z.ZodType<
   WebAnalytics,
@@ -1137,6 +1388,20 @@ export namespace WebAnalytics$ {
   export type Outbound = WebAnalytics$Outbound;
 }
 
+export function webAnalyticsToJSON(webAnalytics: WebAnalytics): string {
+  return JSON.stringify(WebAnalytics$outboundSchema.parse(webAnalytics));
+}
+
+export function webAnalyticsFromJSON(
+  jsonString: string,
+): SafeParseResult<WebAnalytics, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WebAnalytics$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WebAnalytics' from JSON`,
+  );
+}
+
 /** @internal */
 export const FeatureBlocks$inboundSchema: z.ZodType<
   FeatureBlocks,
@@ -1173,6 +1438,20 @@ export namespace FeatureBlocks$ {
   export type Outbound = FeatureBlocks$Outbound;
 }
 
+export function featureBlocksToJSON(featureBlocks: FeatureBlocks): string {
+  return JSON.stringify(FeatureBlocks$outboundSchema.parse(featureBlocks));
+}
+
+export function featureBlocksFromJSON(
+  jsonString: string,
+): SafeParseResult<FeatureBlocks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FeatureBlocks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FeatureBlocks' from JSON`,
+  );
+}
+
 /** @internal */
 export const NorthstarMigration$inboundSchema: z.ZodType<
   NorthstarMigration,
@@ -1227,6 +1506,24 @@ export namespace NorthstarMigration$ {
   export type Outbound = NorthstarMigration$Outbound;
 }
 
+export function northstarMigrationToJSON(
+  northstarMigration: NorthstarMigration,
+): string {
+  return JSON.stringify(
+    NorthstarMigration$outboundSchema.parse(northstarMigration),
+  );
+}
+
+export function northstarMigrationFromJSON(
+  jsonString: string,
+): SafeParseResult<NorthstarMigration, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => NorthstarMigration$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'NorthstarMigration' from JSON`,
+  );
+}
+
 /** @internal */
 export const Version$inboundSchema: z.ZodNativeEnum<typeof Version> = z
   .nativeEnum(Version);
@@ -1374,3 +1671,17 @@ export namespace AuthUser$ {
   /** @deprecated use `AuthUser$Outbound` instead. */
   export type Outbound = AuthUser$Outbound;
 }
+
+export function authUserToJSON(authUser: AuthUser): string {
+  return JSON.stringify(AuthUser$outboundSchema.parse(authUser));
+}
+
+export function authUserFromJSON(
+  jsonString: string,
+): SafeParseResult<AuthUser, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AuthUser$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AuthUser' from JSON`,
+  );
+}

package/src/models/components/authuserlimited.ts

@@ -3,7 +3,10 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * The user's version. Will either be unset or `northstar`.
@@ -131,3 +134,19 @@ export namespace AuthUserLimited$ {
   /** @deprecated use `AuthUserLimited$Outbound` instead. */
   export type Outbound = AuthUserLimited$Outbound;
 }
+
+export function authUserLimitedToJSON(
+  authUserLimited: AuthUserLimited,
+): string {
+  return JSON.stringify(AuthUserLimited$outboundSchema.parse(authUserLimited));
+}
+
+export function authUserLimitedFromJSON(
+  jsonString: string,
+): SafeParseResult<AuthUserLimited, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AuthUserLimited$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AuthUserLimited' from JSON`,
+  );
+}

package/src/models/components/edgeconfigitem.ts

@@ -3,6 +3,9 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   EdgeConfigItemValue,
   EdgeConfigItemValue$inboundSchema,
@@ -72,3 +75,17 @@ export namespace EdgeConfigItem$ {
   /** @deprecated use `EdgeConfigItem$Outbound` instead. */
   export type Outbound = EdgeConfigItem$Outbound;
 }
+
+export function edgeConfigItemToJSON(edgeConfigItem: EdgeConfigItem): string {
+  return JSON.stringify(EdgeConfigItem$outboundSchema.parse(edgeConfigItem));
+}
+
+export function edgeConfigItemFromJSON(
+  jsonString: string,
+): SafeParseResult<EdgeConfigItem, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EdgeConfigItem$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EdgeConfigItem' from JSON`,
+  );
+}

package/src/models/components/edgeconfigitemvalue.ts

@@ -3,6 +3,9 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type EdgeConfigItemValue = string | number | boolean | {
   [k: string]: EdgeConfigItemValue;
@@ -51,3 +54,21 @@ export namespace EdgeConfigItemValue$ {
   /** @deprecated use `EdgeConfigItemValue$Outbound` instead. */
   export type Outbound = EdgeConfigItemValue$Outbound;
 }
+
+export function edgeConfigItemValueToJSON(
+  edgeConfigItemValue: EdgeConfigItemValue,
+): string {
+  return JSON.stringify(
+    EdgeConfigItemValue$outboundSchema.parse(edgeConfigItemValue),
+  );
+}
+
+export function edgeConfigItemValueFromJSON(
+  jsonString: string,
+): SafeParseResult<EdgeConfigItemValue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EdgeConfigItemValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EdgeConfigItemValue' from JSON`,
+  );
+}

package/src/models/components/edgeconfigtoken.ts

@@ -3,6 +3,9 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * The EdgeConfig.
@@ -65,3 +68,19 @@ export namespace EdgeConfigToken$ {
   /** @deprecated use `EdgeConfigToken$Outbound` instead. */
   export type Outbound = EdgeConfigToken$Outbound;
 }
+
+export function edgeConfigTokenToJSON(
+  edgeConfigToken: EdgeConfigToken,
+): string {
+  return JSON.stringify(EdgeConfigToken$outboundSchema.parse(edgeConfigToken));
+}
+
+export function edgeConfigTokenFromJSON(
+  jsonString: string,
+): SafeParseResult<EdgeConfigToken, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EdgeConfigToken$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EdgeConfigToken' from JSON`,
+  );
+}

package/src/models/components/filetree.ts

@@ -3,7 +3,10 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * String indicating the type of file tree entry.
@@ -128,3 +131,17 @@ export namespace FileTree$ {
   /** @deprecated use `FileTree$Outbound` instead. */
   export type Outbound = FileTree$Outbound;
 }
+
+export function fileTreeToJSON(fileTree: FileTree): string {
+  return JSON.stringify(FileTree$outboundSchema.parse(fileTree));
+}
+
+export function fileTreeFromJSON(
+  jsonString: string,
+): SafeParseResult<FileTree, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FileTree$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileTree' from JSON`,
+  );
+}

package/src/models/components/flagjsonvalue.ts

@@ -3,6 +3,9 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type FlagJSONValue = string | number | boolean | Array<FlagJSONValue> | {
   [k: string]: FlagJSONValue;
@@ -54,3 +57,17 @@ export namespace FlagJSONValue$ {
   /** @deprecated use `FlagJSONValue$Outbound` instead. */
   export type Outbound = FlagJSONValue$Outbound;
 }
+
+export function flagJSONValueToJSON(flagJSONValue: FlagJSONValue): string {
+  return JSON.stringify(FlagJSONValue$outboundSchema.parse(flagJSONValue));
+}
+
+export function flagJSONValueFromJSON(
+  jsonString: string,
+): SafeParseResult<FlagJSONValue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FlagJSONValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FlagJSONValue' from JSON`,
+  );
+}

package/src/models/components/pagination.ts

@@ -3,6 +3,9 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * This object contains information related to the pagination of the current request, including the necessary parameters to get the next or previous page of data.
@@ -63,3 +66,17 @@ export namespace Pagination$ {
   /** @deprecated use `Pagination$Outbound` instead. */
   export type Outbound = Pagination$Outbound;
 }
+
+export function paginationToJSON(pagination: Pagination): string {
+  return JSON.stringify(Pagination$outboundSchema.parse(pagination));
+}
+
+export function paginationFromJSON(
+  jsonString: string,
+): SafeParseResult<Pagination, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Pagination$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Pagination' from JSON`,
+  );
+}

package/src/models/components/security.ts

@@ -3,6 +3,9 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type Security = {
   bearerToken: string;
@@ -43,3 +46,17 @@ export namespace Security$ {
   /** @deprecated use `Security$Outbound` instead. */
   export type Outbound = Security$Outbound;
 }
+
+export function securityToJSON(security: Security): string {
+  return JSON.stringify(Security$outboundSchema.parse(security));
+}
+
+export function securityFromJSON(
+  jsonString: string,
+): SafeParseResult<Security, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Security$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Security' from JSON`,
+  );
+}