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

package/src/models/components/teamlimited.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";
 
 /**
  * Information for the SAML Single Sign-On configuration.
@@ -222,6 +225,20 @@ export namespace Connection$ {
   export type Outbound = Connection$Outbound;
 }
 
+export function connectionToJSON(connection: Connection): string {
+  return JSON.stringify(Connection$outboundSchema.parse(connection));
+}
+
+export function connectionFromJSON(
+  jsonString: string,
+): SafeParseResult<Connection, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Connection$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Connection' from JSON`,
+  );
+}
+
 /** @internal */
 export const Directory$inboundSchema: z.ZodType<
   Directory,
@@ -267,6 +284,20 @@ export namespace Directory$ {
   export type Outbound = Directory$Outbound;
 }
 
+export function directoryToJSON(directory: Directory): string {
+  return JSON.stringify(Directory$outboundSchema.parse(directory));
+}
+
+export function directoryFromJSON(
+  jsonString: string,
+): SafeParseResult<Directory, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Directory$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Directory' from JSON`,
+  );
+}
+
 /** @internal */
 export const Saml$inboundSchema: z.ZodType<Saml, z.ZodTypeDef, unknown> = z
   .object({
@@ -303,6 +334,20 @@ export namespace Saml$ {
   export type Outbound = Saml$Outbound;
 }
 
+export function samlToJSON(saml: Saml): string {
+  return JSON.stringify(Saml$outboundSchema.parse(saml));
+}
+
+export function samlFromJSON(
+  jsonString: string,
+): SafeParseResult<Saml, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Saml$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Saml' from JSON`,
+  );
+}
+
 /** @internal */
 export const Entitlements$inboundSchema: z.ZodType<
   Entitlements,
@@ -339,6 +384,20 @@ export namespace Entitlements$ {
   export type Outbound = Entitlements$Outbound;
 }
 
+export function entitlementsToJSON(entitlements: Entitlements): string {
+  return JSON.stringify(Entitlements$outboundSchema.parse(entitlements));
+}
+
+export function entitlementsFromJSON(
+  jsonString: string,
+): SafeParseResult<Entitlements, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Entitlements$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Entitlements' from JSON`,
+  );
+}
+
 /** @internal */
 export const Role$inboundSchema: z.ZodNativeEnum<typeof Role> = z.nativeEnum(
   Role,
@@ -408,6 +467,20 @@ export namespace GitUserId$ {
   export type Outbound = GitUserId$Outbound;
 }
 
+export function gitUserIdToJSON(gitUserId: GitUserId): string {
+  return JSON.stringify(GitUserId$outboundSchema.parse(gitUserId));
+}
+
+export function gitUserIdFromJSON(
+  jsonString: string,
+): SafeParseResult<GitUserId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GitUserId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GitUserId' from JSON`,
+  );
+}
+
 /** @internal */
 export const JoinedFrom$inboundSchema: z.ZodType<
   JoinedFrom,
@@ -474,6 +547,20 @@ export namespace JoinedFrom$ {
   export type Outbound = JoinedFrom$Outbound;
 }
 
+export function joinedFromToJSON(joinedFrom: JoinedFrom): string {
+  return JSON.stringify(JoinedFrom$outboundSchema.parse(joinedFrom));
+}
+
+export function joinedFromFromJSON(
+  jsonString: string,
+): SafeParseResult<JoinedFrom, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => JoinedFrom$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'JoinedFrom' from JSON`,
+  );
+}
+
 /** @internal */
 export const Membership$inboundSchema: z.ZodType<
   Membership,
@@ -537,6 +624,20 @@ export namespace Membership$ {
   export type Outbound = Membership$Outbound;
 }
 
+export function membershipToJSON(membership: Membership): string {
+  return JSON.stringify(Membership$outboundSchema.parse(membership));
+}
+
+export function membershipFromJSON(
+  jsonString: string,
+): SafeParseResult<Membership, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Membership$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Membership' from JSON`,
+  );
+}
+
 /** @internal */
 export const TeamLimited$inboundSchema: z.ZodType<
   TeamLimited,
@@ -596,3 +697,17 @@ export namespace TeamLimited$ {
   /** @deprecated use `TeamLimited$Outbound` instead. */
   export type Outbound = TeamLimited$Outbound;
 }
+
+export function teamLimitedToJSON(teamLimited: TeamLimited): string {
+  return JSON.stringify(TeamLimited$outboundSchema.parse(teamLimited));
+}
+
+export function teamLimitedFromJSON(
+  jsonString: string,
+): SafeParseResult<TeamLimited, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TeamLimited$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TeamLimited' from JSON`,
+  );
+}

package/src/models/components/userevent.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";
 
 /**
  * Array of events generated by the User.
@@ -38,3 +41,17 @@ export namespace UserEvent$ {
   /** @deprecated use `UserEvent$Outbound` instead. */
   export type Outbound = UserEvent$Outbound;
 }
+
+export function userEventToJSON(userEvent: UserEvent): string {
+  return JSON.stringify(UserEvent$outboundSchema.parse(userEvent));
+}
+
+export function userEventFromJSON(
+  jsonString: string,
+): SafeParseResult<UserEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UserEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UserEvent' from JSON`,
+  );
+}

package/src/models/operations/addprojectdomain.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 { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * Status code for domain redirect
@@ -161,6 +164,26 @@ export namespace AddProjectDomainRequestBody$ {
   export type Outbound = AddProjectDomainRequestBody$Outbound;
 }
 
+export function addProjectDomainRequestBodyToJSON(
+  addProjectDomainRequestBody: AddProjectDomainRequestBody,
+): string {
+  return JSON.stringify(
+    AddProjectDomainRequestBody$outboundSchema.parse(
+      addProjectDomainRequestBody,
+    ),
+  );
+}
+
+export function addProjectDomainRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<AddProjectDomainRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddProjectDomainRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddProjectDomainRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const AddProjectDomainRequest$inboundSchema: z.ZodType<
   AddProjectDomainRequest,
@@ -216,6 +239,24 @@ export namespace AddProjectDomainRequest$ {
   export type Outbound = AddProjectDomainRequest$Outbound;
 }
 
+export function addProjectDomainRequestToJSON(
+  addProjectDomainRequest: AddProjectDomainRequest,
+): string {
+  return JSON.stringify(
+    AddProjectDomainRequest$outboundSchema.parse(addProjectDomainRequest),
+  );
+}
+
+export function addProjectDomainRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<AddProjectDomainRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddProjectDomainRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddProjectDomainRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const AddProjectDomainVerification$inboundSchema: z.ZodType<
   AddProjectDomainVerification,
@@ -261,6 +302,26 @@ export namespace AddProjectDomainVerification$ {
   export type Outbound = AddProjectDomainVerification$Outbound;
 }
 
+export function addProjectDomainVerificationToJSON(
+  addProjectDomainVerification: AddProjectDomainVerification,
+): string {
+  return JSON.stringify(
+    AddProjectDomainVerification$outboundSchema.parse(
+      addProjectDomainVerification,
+    ),
+  );
+}
+
+export function addProjectDomainVerificationFromJSON(
+  jsonString: string,
+): SafeParseResult<AddProjectDomainVerification, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddProjectDomainVerification$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddProjectDomainVerification' from JSON`,
+  );
+}
+
 /** @internal */
 export const AddProjectDomainResponseBody$inboundSchema: z.ZodType<
   AddProjectDomainResponseBody,
@@ -330,3 +391,23 @@ export namespace AddProjectDomainResponseBody$ {
   /** @deprecated use `AddProjectDomainResponseBody$Outbound` instead. */
   export type Outbound = AddProjectDomainResponseBody$Outbound;
 }
+
+export function addProjectDomainResponseBodyToJSON(
+  addProjectDomainResponseBody: AddProjectDomainResponseBody,
+): string {
+  return JSON.stringify(
+    AddProjectDomainResponseBody$outboundSchema.parse(
+      addProjectDomainResponseBody,
+    ),
+  );
+}
+
+export function addProjectDomainResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<AddProjectDomainResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddProjectDomainResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddProjectDomainResponseBody' from JSON`,
+  );
+}

package/src/models/operations/addprojectmember.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 { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
  * The project role of the member that will be added.
@@ -206,6 +209,26 @@ export namespace AddProjectMemberRequestBody3$ {
   export type Outbound = AddProjectMemberRequestBody3$Outbound;
 }
 
+export function addProjectMemberRequestBody3ToJSON(
+  addProjectMemberRequestBody3: AddProjectMemberRequestBody3,
+): string {
+  return JSON.stringify(
+    AddProjectMemberRequestBody3$outboundSchema.parse(
+      addProjectMemberRequestBody3,
+    ),
+  );
+}
+
+export function addProjectMemberRequestBody3FromJSON(
+  jsonString: string,
+): SafeParseResult<AddProjectMemberRequestBody3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddProjectMemberRequestBody3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddProjectMemberRequestBody3' from JSON`,
+  );
+}
+
 /** @internal */
 export const AddProjectMemberRequestBodyRole$inboundSchema: z.ZodNativeEnum<
   typeof AddProjectMemberRequestBodyRole
@@ -272,6 +295,26 @@ export namespace AddProjectMemberRequestBody2$ {
   export type Outbound = AddProjectMemberRequestBody2$Outbound;
 }
 
+export function addProjectMemberRequestBody2ToJSON(
+  addProjectMemberRequestBody2: AddProjectMemberRequestBody2,
+): string {
+  return JSON.stringify(
+    AddProjectMemberRequestBody2$outboundSchema.parse(
+      addProjectMemberRequestBody2,
+    ),
+  );
+}
+
+export function addProjectMemberRequestBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<AddProjectMemberRequestBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddProjectMemberRequestBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddProjectMemberRequestBody2' from JSON`,
+  );
+}
+
 /** @internal */
 export const RequestBodyRole$inboundSchema: z.ZodNativeEnum<
   typeof RequestBodyRole
@@ -338,6 +381,26 @@ export namespace AddProjectMemberRequestBody1$ {
   export type Outbound = AddProjectMemberRequestBody1$Outbound;
 }
 
+export function addProjectMemberRequestBody1ToJSON(
+  addProjectMemberRequestBody1: AddProjectMemberRequestBody1,
+): string {
+  return JSON.stringify(
+    AddProjectMemberRequestBody1$outboundSchema.parse(
+      addProjectMemberRequestBody1,
+    ),
+  );
+}
+
+export function addProjectMemberRequestBody1FromJSON(
+  jsonString: string,
+): SafeParseResult<AddProjectMemberRequestBody1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddProjectMemberRequestBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddProjectMemberRequestBody1' from JSON`,
+  );
+}
+
 /** @internal */
 export const AddProjectMemberRequestBody$inboundSchema: z.ZodType<
   AddProjectMemberRequestBody,
@@ -379,6 +442,26 @@ export namespace AddProjectMemberRequestBody$ {
   export type Outbound = AddProjectMemberRequestBody$Outbound;
 }
 
+export function addProjectMemberRequestBodyToJSON(
+  addProjectMemberRequestBody: AddProjectMemberRequestBody,
+): string {
+  return JSON.stringify(
+    AddProjectMemberRequestBody$outboundSchema.parse(
+      addProjectMemberRequestBody,
+    ),
+  );
+}
+
+export function addProjectMemberRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<AddProjectMemberRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddProjectMemberRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddProjectMemberRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const AddProjectMemberRequest$inboundSchema: z.ZodType<
   AddProjectMemberRequest,
@@ -444,6 +527,24 @@ export namespace AddProjectMemberRequest$ {
   export type Outbound = AddProjectMemberRequest$Outbound;
 }
 
+export function addProjectMemberRequestToJSON(
+  addProjectMemberRequest: AddProjectMemberRequest,
+): string {
+  return JSON.stringify(
+    AddProjectMemberRequest$outboundSchema.parse(addProjectMemberRequest),
+  );
+}
+
+export function addProjectMemberRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<AddProjectMemberRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddProjectMemberRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddProjectMemberRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const AddProjectMemberResponseBody$inboundSchema: z.ZodType<
   AddProjectMemberResponseBody,
@@ -479,3 +580,23 @@ export namespace AddProjectMemberResponseBody$ {
   /** @deprecated use `AddProjectMemberResponseBody$Outbound` instead. */
   export type Outbound = AddProjectMemberResponseBody$Outbound;
 }
+
+export function addProjectMemberResponseBodyToJSON(
+  addProjectMemberResponseBody: AddProjectMemberResponseBody,
+): string {
+  return JSON.stringify(
+    AddProjectMemberResponseBody$outboundSchema.parse(
+      addProjectMemberResponseBody,
+    ),
+  );
+}
+
+export function addProjectMemberResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<AddProjectMemberResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddProjectMemberResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddProjectMemberResponseBody' from JSON`,
+  );
+}

package/src/models/operations/artifactexists.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 ArtifactExistsRequest = {
   /**
@@ -60,3 +63,21 @@ export namespace ArtifactExistsRequest$ {
   /** @deprecated use `ArtifactExistsRequest$Outbound` instead. */
   export type Outbound = ArtifactExistsRequest$Outbound;
 }
+
+export function artifactExistsRequestToJSON(
+  artifactExistsRequest: ArtifactExistsRequest,
+): string {
+  return JSON.stringify(
+    ArtifactExistsRequest$outboundSchema.parse(artifactExistsRequest),
+  );
+}
+
+export function artifactExistsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ArtifactExistsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ArtifactExistsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ArtifactExistsRequest' from JSON`,
+  );
+}

package/src/models/operations/artifactquery.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 ArtifactQueryRequestBody = {
   /**
@@ -76,6 +79,24 @@ export namespace ArtifactQueryRequestBody$ {
   export type Outbound = ArtifactQueryRequestBody$Outbound;
 }
 
+export function artifactQueryRequestBodyToJSON(
+  artifactQueryRequestBody: ArtifactQueryRequestBody,
+): string {
+  return JSON.stringify(
+    ArtifactQueryRequestBody$outboundSchema.parse(artifactQueryRequestBody),
+  );
+}
+
+export function artifactQueryRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ArtifactQueryRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ArtifactQueryRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ArtifactQueryRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const ArtifactQueryRequest$inboundSchema: z.ZodType<
   ArtifactQueryRequest,
@@ -126,6 +147,24 @@ export namespace ArtifactQueryRequest$ {
   export type Outbound = ArtifactQueryRequest$Outbound;
 }
 
+export function artifactQueryRequestToJSON(
+  artifactQueryRequest: ArtifactQueryRequest,
+): string {
+  return JSON.stringify(
+    ArtifactQueryRequest$outboundSchema.parse(artifactQueryRequest),
+  );
+}
+
+export function artifactQueryRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ArtifactQueryRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ArtifactQueryRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ArtifactQueryRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const ErrorT$inboundSchema: z.ZodType<ErrorT, z.ZodTypeDef, unknown> = z
   .object({
@@ -159,6 +198,20 @@ export namespace ErrorT$ {
   export type Outbound = ErrorT$Outbound;
 }
 
+export function errorTToJSON(errorT: ErrorT): string {
+  return JSON.stringify(ErrorT$outboundSchema.parse(errorT));
+}
+
+export function errorTFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorT' from JSON`,
+  );
+}
+
 /** @internal */
 export const ResponseBody2$inboundSchema: z.ZodType<
   ResponseBody2,
@@ -195,6 +248,20 @@ export namespace ResponseBody2$ {
   export type Outbound = ResponseBody2$Outbound;
 }
 
+export function responseBody2ToJSON(responseBody2: ResponseBody2): string {
+  return JSON.stringify(ResponseBody2$outboundSchema.parse(responseBody2));
+}
+
+export function responseBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBody2' from JSON`,
+  );
+}
+
 /** @internal */
 export const ResponseBody1$inboundSchema: z.ZodType<
   ResponseBody1,
@@ -237,6 +304,20 @@ export namespace ResponseBody1$ {
   export type Outbound = ResponseBody1$Outbound;
 }
 
+export function responseBody1ToJSON(responseBody1: ResponseBody1): string {
+  return JSON.stringify(ResponseBody1$outboundSchema.parse(responseBody1));
+}
+
+export function responseBody1FromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBody1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBody1' from JSON`,
+  );
+}
+
 /** @internal */
 export const ResponseBody$inboundSchema: z.ZodType<
   ResponseBody,
@@ -274,3 +355,17 @@ export namespace ResponseBody$ {
   /** @deprecated use `ResponseBody$Outbound` instead. */
   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`,
+  );
+}