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

package/src/models/operations/createedgeconfig.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";
 
 export type Two5 = {};
 
@@ -115,6 +118,20 @@ export namespace Two5$ {
   export type Outbound = Two5$Outbound;
 }
 
+export function two5ToJSON(two5: Two5): string {
+  return JSON.stringify(Two5$outboundSchema.parse(two5));
+}
+
+export function two5FromJSON(
+  jsonString: string,
+): SafeParseResult<Two5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Two5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Two5' from JSON`,
+  );
+}
+
 /** @internal */
 export const Items2$inboundSchema: z.ZodType<Items2, z.ZodTypeDef, unknown> = z
   .union([
@@ -154,6 +171,20 @@ export namespace Items2$ {
   export type Outbound = Items2$Outbound;
 }
 
+export function items2ToJSON(items2: Items2): string {
+  return JSON.stringify(Items2$outboundSchema.parse(items2));
+}
+
+export function items2FromJSON(
+  jsonString: string,
+): SafeParseResult<Items2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Items2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Items2' from JSON`,
+  );
+}
+
 /** @internal */
 export const One5$inboundSchema: z.ZodType<One5, z.ZodTypeDef, unknown> = z
   .object({});
@@ -178,6 +209,20 @@ export namespace One5$ {
   export type Outbound = One5$Outbound;
 }
 
+export function one5ToJSON(one5: One5): string {
+  return JSON.stringify(One5$outboundSchema.parse(one5));
+}
+
+export function one5FromJSON(
+  jsonString: string,
+): SafeParseResult<One5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => One5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'One5' from JSON`,
+  );
+}
+
 /** @internal */
 export const Items1$inboundSchema: z.ZodType<Items1, z.ZodTypeDef, unknown> = z
   .union([
@@ -217,6 +262,20 @@ export namespace Items1$ {
   export type Outbound = Items1$Outbound;
 }
 
+export function items1ToJSON(items1: Items1): string {
+  return JSON.stringify(Items1$outboundSchema.parse(items1));
+}
+
+export function items1FromJSON(
+  jsonString: string,
+): SafeParseResult<Items1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Items1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Items1' from JSON`,
+  );
+}
+
 /** @internal */
 export const Items$inboundSchema: z.ZodType<Items, z.ZodTypeDef, unknown> = z
   .union([
@@ -284,6 +343,20 @@ export namespace Items$ {
   export type Outbound = Items$Outbound;
 }
 
+export function itemsToJSON(items: Items): string {
+  return JSON.stringify(Items$outboundSchema.parse(items));
+}
+
+export function itemsFromJSON(
+  jsonString: string,
+): SafeParseResult<Items, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Items$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Items' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigRequestBody$inboundSchema: z.ZodType<
   CreateEdgeConfigRequestBody,
@@ -369,6 +442,26 @@ export namespace CreateEdgeConfigRequestBody$ {
   export type Outbound = CreateEdgeConfigRequestBody$Outbound;
 }
 
+export function createEdgeConfigRequestBodyToJSON(
+  createEdgeConfigRequestBody: CreateEdgeConfigRequestBody,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigRequestBody$outboundSchema.parse(
+      createEdgeConfigRequestBody,
+    ),
+  );
+}
+
+export function createEdgeConfigRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigRequest$inboundSchema: z.ZodType<
   CreateEdgeConfigRequest,
@@ -421,6 +514,24 @@ export namespace CreateEdgeConfigRequest$ {
   export type Outbound = CreateEdgeConfigRequest$Outbound;
 }
 
+export function createEdgeConfigRequestToJSON(
+  createEdgeConfigRequest: CreateEdgeConfigRequest,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigRequest$outboundSchema.parse(createEdgeConfigRequest),
+  );
+}
+
+export function createEdgeConfigRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigTransfer$inboundSchema: z.ZodType<
   CreateEdgeConfigTransfer,
@@ -463,6 +574,24 @@ export namespace CreateEdgeConfigTransfer$ {
   export type Outbound = CreateEdgeConfigTransfer$Outbound;
 }
 
+export function createEdgeConfigTransferToJSON(
+  createEdgeConfigTransfer: CreateEdgeConfigTransfer,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigTransfer$outboundSchema.parse(createEdgeConfigTransfer),
+  );
+}
+
+export function createEdgeConfigTransferFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigTransfer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigTransfer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigTransfer' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigSchema$inboundSchema: z.ZodType<
   CreateEdgeConfigSchema,
@@ -493,6 +622,24 @@ export namespace CreateEdgeConfigSchema$ {
   export type Outbound = CreateEdgeConfigSchema$Outbound;
 }
 
+export function createEdgeConfigSchemaToJSON(
+  createEdgeConfigSchema: CreateEdgeConfigSchema,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigSchema$outboundSchema.parse(createEdgeConfigSchema),
+  );
+}
+
+export function createEdgeConfigSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigType$inboundSchema: z.ZodNativeEnum<
   typeof CreateEdgeConfigType
@@ -553,6 +700,24 @@ export namespace CreateEdgeConfigPurpose$ {
   export type Outbound = CreateEdgeConfigPurpose$Outbound;
 }
 
+export function createEdgeConfigPurposeToJSON(
+  createEdgeConfigPurpose: CreateEdgeConfigPurpose,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigPurpose$outboundSchema.parse(createEdgeConfigPurpose),
+  );
+}
+
+export function createEdgeConfigPurposeFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigPurpose, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigPurpose$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigPurpose' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigResponseBody$inboundSchema: z.ZodType<
   CreateEdgeConfigResponseBody,
@@ -618,3 +783,23 @@ export namespace CreateEdgeConfigResponseBody$ {
   /** @deprecated use `CreateEdgeConfigResponseBody$Outbound` instead. */
   export type Outbound = CreateEdgeConfigResponseBody$Outbound;
 }
+
+export function createEdgeConfigResponseBodyToJSON(
+  createEdgeConfigResponseBody: CreateEdgeConfigResponseBody,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigResponseBody$outboundSchema.parse(
+      createEdgeConfigResponseBody,
+    ),
+  );
+}
+
+export function createEdgeConfigResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigResponseBody' from JSON`,
+  );
+}

package/src/models/operations/createedgeconfigtoken.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 CreateEdgeConfigTokenRequestBody = {
   label: string;
@@ -63,6 +66,26 @@ export namespace CreateEdgeConfigTokenRequestBody$ {
   export type Outbound = CreateEdgeConfigTokenRequestBody$Outbound;
 }
 
+export function createEdgeConfigTokenRequestBodyToJSON(
+  createEdgeConfigTokenRequestBody: CreateEdgeConfigTokenRequestBody,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigTokenRequestBody$outboundSchema.parse(
+      createEdgeConfigTokenRequestBody,
+    ),
+  );
+}
+
+export function createEdgeConfigTokenRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigTokenRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigTokenRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigTokenRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigTokenRequest$inboundSchema: z.ZodType<
   CreateEdgeConfigTokenRequest,
@@ -118,6 +141,26 @@ export namespace CreateEdgeConfigTokenRequest$ {
   export type Outbound = CreateEdgeConfigTokenRequest$Outbound;
 }
 
+export function createEdgeConfigTokenRequestToJSON(
+  createEdgeConfigTokenRequest: CreateEdgeConfigTokenRequest,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigTokenRequest$outboundSchema.parse(
+      createEdgeConfigTokenRequest,
+    ),
+  );
+}
+
+export function createEdgeConfigTokenRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigTokenRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigTokenRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigTokenRequest' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEdgeConfigTokenResponseBody$inboundSchema: z.ZodType<
   CreateEdgeConfigTokenResponseBody,
@@ -157,3 +200,23 @@ export namespace CreateEdgeConfigTokenResponseBody$ {
   /** @deprecated use `CreateEdgeConfigTokenResponseBody$Outbound` instead. */
   export type Outbound = CreateEdgeConfigTokenResponseBody$Outbound;
 }
+
+export function createEdgeConfigTokenResponseBodyToJSON(
+  createEdgeConfigTokenResponseBody: CreateEdgeConfigTokenResponseBody,
+): string {
+  return JSON.stringify(
+    CreateEdgeConfigTokenResponseBody$outboundSchema.parse(
+      createEdgeConfigTokenResponseBody,
+    ),
+  );
+}
+
+export function createEdgeConfigTokenResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEdgeConfigTokenResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEdgeConfigTokenResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEdgeConfigTokenResponseBody' from JSON`,
+  );
+}