dub 0.45.2 → 0.45.4

package/src/models/components/linkschema.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";
 import {
   TagSchema,
   TagSchema$inboundSchema,
@@ -1729,6 +1732,20 @@ export namespace Geo$ {
   export type Outbound = Geo$Outbound;
 }
 
+export function geoToJSON(geo: Geo): string {
+  return JSON.stringify(Geo$outboundSchema.parse(geo));
+}
+
+export function geoFromJSON(
+  jsonString: string,
+): SafeParseResult<Geo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Geo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Geo' from JSON`,
+  );
+}
+
 /** @internal */
 export const LinkSchema$inboundSchema: z.ZodType<
   LinkSchema,
@@ -1906,3 +1923,17 @@ export namespace LinkSchema$ {
   /** @deprecated use `LinkSchema$Outbound` instead. */
   export type Outbound = LinkSchema$Outbound;
 }
+
+export function linkSchemaToJSON(linkSchema: LinkSchema): string {
+  return JSON.stringify(LinkSchema$outboundSchema.parse(linkSchema));
+}
+
+export function linkSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<LinkSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LinkSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LinkSchema' from JSON`,
+  );
+}

package/src/models/components/linkwebhookevent.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";
 import {
   TagSchema,
   TagSchema$inboundSchema,
@@ -524,6 +527,24 @@ export namespace LinkWebhookEventEvent$ {
   export type Outbound = LinkWebhookEventEvent$Outbound;
 }
 
+export function linkWebhookEventEventToJSON(
+  linkWebhookEventEvent: LinkWebhookEventEvent,
+): string {
+  return JSON.stringify(
+    LinkWebhookEventEvent$outboundSchema.parse(linkWebhookEventEvent),
+  );
+}
+
+export function linkWebhookEventEventFromJSON(
+  jsonString: string,
+): SafeParseResult<LinkWebhookEventEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LinkWebhookEventEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LinkWebhookEventEvent' from JSON`,
+  );
+}
+
 /** @internal */
 export const LinkWebhookEventGeo$inboundSchema: z.ZodType<
   LinkWebhookEventGeo,
@@ -1813,6 +1834,24 @@ export namespace LinkWebhookEventGeo$ {
   export type Outbound = LinkWebhookEventGeo$Outbound;
 }
 
+export function linkWebhookEventGeoToJSON(
+  linkWebhookEventGeo: LinkWebhookEventGeo,
+): string {
+  return JSON.stringify(
+    LinkWebhookEventGeo$outboundSchema.parse(linkWebhookEventGeo),
+  );
+}
+
+export function linkWebhookEventGeoFromJSON(
+  jsonString: string,
+): SafeParseResult<LinkWebhookEventGeo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LinkWebhookEventGeo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LinkWebhookEventGeo' from JSON`,
+  );
+}
+
 /** @internal */
 export const Data$inboundSchema: z.ZodType<Data, z.ZodTypeDef, unknown> = z
   .object({
@@ -1985,6 +2024,20 @@ export namespace Data$ {
   export type Outbound = Data$Outbound;
 }
 
+export function dataToJSON(data: Data): string {
+  return JSON.stringify(Data$outboundSchema.parse(data));
+}
+
+export function dataFromJSON(
+  jsonString: string,
+): SafeParseResult<Data, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Data$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Data' from JSON`,
+  );
+}
+
 /** @internal */
 export const LinkWebhookEvent$inboundSchema: z.ZodType<
   LinkWebhookEvent,
@@ -2033,3 +2086,21 @@ export namespace LinkWebhookEvent$ {
   /** @deprecated use `LinkWebhookEvent$Outbound` instead. */
   export type Outbound = LinkWebhookEvent$Outbound;
 }
+
+export function linkWebhookEventToJSON(
+  linkWebhookEvent: LinkWebhookEvent,
+): string {
+  return JSON.stringify(
+    LinkWebhookEvent$outboundSchema.parse(linkWebhookEvent),
+  );
+}
+
+export function linkWebhookEventFromJSON(
+  jsonString: string,
+): SafeParseResult<LinkWebhookEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LinkWebhookEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LinkWebhookEvent' from JSON`,
+  );
+}

package/src/models/components/salecreatedevent.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";
 import {
   TagSchema,
   TagSchema$inboundSchema,
@@ -555,6 +558,24 @@ export namespace SaleCreatedEventCustomer$ {
   export type Outbound = SaleCreatedEventCustomer$Outbound;
 }
 
+export function saleCreatedEventCustomerToJSON(
+  saleCreatedEventCustomer: SaleCreatedEventCustomer,
+): string {
+  return JSON.stringify(
+    SaleCreatedEventCustomer$outboundSchema.parse(saleCreatedEventCustomer),
+  );
+}
+
+export function saleCreatedEventCustomerFromJSON(
+  jsonString: string,
+): SafeParseResult<SaleCreatedEventCustomer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SaleCreatedEventCustomer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SaleCreatedEventCustomer' from JSON`,
+  );
+}
+
 /** @internal */
 export const SaleCreatedEventClick$inboundSchema: z.ZodType<
   SaleCreatedEventClick,
@@ -624,6 +645,24 @@ export namespace SaleCreatedEventClick$ {
   export type Outbound = SaleCreatedEventClick$Outbound;
 }
 
+export function saleCreatedEventClickToJSON(
+  saleCreatedEventClick: SaleCreatedEventClick,
+): string {
+  return JSON.stringify(
+    SaleCreatedEventClick$outboundSchema.parse(saleCreatedEventClick),
+  );
+}
+
+export function saleCreatedEventClickFromJSON(
+  jsonString: string,
+): SafeParseResult<SaleCreatedEventClick, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SaleCreatedEventClick$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SaleCreatedEventClick' from JSON`,
+  );
+}
+
 /** @internal */
 export const SaleCreatedEventGeo$inboundSchema: z.ZodType<
   SaleCreatedEventGeo,
@@ -1913,6 +1952,24 @@ export namespace SaleCreatedEventGeo$ {
   export type Outbound = SaleCreatedEventGeo$Outbound;
 }
 
+export function saleCreatedEventGeoToJSON(
+  saleCreatedEventGeo: SaleCreatedEventGeo,
+): string {
+  return JSON.stringify(
+    SaleCreatedEventGeo$outboundSchema.parse(saleCreatedEventGeo),
+  );
+}
+
+export function saleCreatedEventGeoFromJSON(
+  jsonString: string,
+): SafeParseResult<SaleCreatedEventGeo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SaleCreatedEventGeo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SaleCreatedEventGeo' from JSON`,
+  );
+}
+
 /** @internal */
 export const SaleCreatedEventLink$inboundSchema: z.ZodType<
   SaleCreatedEventLink,
@@ -2091,6 +2148,24 @@ export namespace SaleCreatedEventLink$ {
   export type Outbound = SaleCreatedEventLink$Outbound;
 }
 
+export function saleCreatedEventLinkToJSON(
+  saleCreatedEventLink: SaleCreatedEventLink,
+): string {
+  return JSON.stringify(
+    SaleCreatedEventLink$outboundSchema.parse(saleCreatedEventLink),
+  );
+}
+
+export function saleCreatedEventLinkFromJSON(
+  jsonString: string,
+): SafeParseResult<SaleCreatedEventLink, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SaleCreatedEventLink$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SaleCreatedEventLink' from JSON`,
+  );
+}
+
 /** @internal */
 export const SaleCreatedEventSale$inboundSchema: z.ZodType<
   SaleCreatedEventSale,
@@ -2136,6 +2211,24 @@ export namespace SaleCreatedEventSale$ {
   export type Outbound = SaleCreatedEventSale$Outbound;
 }
 
+export function saleCreatedEventSaleToJSON(
+  saleCreatedEventSale: SaleCreatedEventSale,
+): string {
+  return JSON.stringify(
+    SaleCreatedEventSale$outboundSchema.parse(saleCreatedEventSale),
+  );
+}
+
+export function saleCreatedEventSaleFromJSON(
+  jsonString: string,
+): SafeParseResult<SaleCreatedEventSale, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SaleCreatedEventSale$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SaleCreatedEventSale' from JSON`,
+  );
+}
+
 /** @internal */
 export const SaleCreatedEventData$inboundSchema: z.ZodType<
   SaleCreatedEventData,
@@ -2184,6 +2277,24 @@ export namespace SaleCreatedEventData$ {
   export type Outbound = SaleCreatedEventData$Outbound;
 }
 
+export function saleCreatedEventDataToJSON(
+  saleCreatedEventData: SaleCreatedEventData,
+): string {
+  return JSON.stringify(
+    SaleCreatedEventData$outboundSchema.parse(saleCreatedEventData),
+  );
+}
+
+export function saleCreatedEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<SaleCreatedEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SaleCreatedEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SaleCreatedEventData' from JSON`,
+  );
+}
+
 /** @internal */
 export const SaleCreatedEvent$inboundSchema: z.ZodType<
   SaleCreatedEvent,
@@ -2228,3 +2339,21 @@ export namespace SaleCreatedEvent$ {
   /** @deprecated use `SaleCreatedEvent$Outbound` instead. */
   export type Outbound = SaleCreatedEvent$Outbound;
 }
+
+export function saleCreatedEventToJSON(
+  saleCreatedEvent: SaleCreatedEvent,
+): string {
+  return JSON.stringify(
+    SaleCreatedEvent$outboundSchema.parse(saleCreatedEvent),
+  );
+}
+
+export function saleCreatedEventFromJSON(
+  jsonString: string,
+): SafeParseResult<SaleCreatedEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SaleCreatedEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SaleCreatedEvent' from JSON`,
+  );
+}

package/src/models/components/saleevent.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";
 import {
   TagSchema,
   TagSchema$inboundSchema,
@@ -1901,6 +1904,20 @@ export namespace SaleEventGeo$ {
   export type Outbound = SaleEventGeo$Outbound;
 }
 
+export function saleEventGeoToJSON(saleEventGeo: SaleEventGeo): string {
+  return JSON.stringify(SaleEventGeo$outboundSchema.parse(saleEventGeo));
+}
+
+export function saleEventGeoFromJSON(
+  jsonString: string,
+): SafeParseResult<SaleEventGeo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SaleEventGeo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SaleEventGeo' from JSON`,
+  );
+}
+
 /** @internal */
 export const SaleEventLink$inboundSchema: z.ZodType<
   SaleEventLink,
@@ -2079,6 +2096,20 @@ export namespace SaleEventLink$ {
   export type Outbound = SaleEventLink$Outbound;
 }
 
+export function saleEventLinkToJSON(saleEventLink: SaleEventLink): string {
+  return JSON.stringify(SaleEventLink$outboundSchema.parse(saleEventLink));
+}
+
+export function saleEventLinkFromJSON(
+  jsonString: string,
+): SafeParseResult<SaleEventLink, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SaleEventLink$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SaleEventLink' from JSON`,
+  );
+}
+
 /** @internal */
 export const SaleEventClick$inboundSchema: z.ZodType<
   SaleEventClick,
@@ -2148,6 +2179,20 @@ export namespace SaleEventClick$ {
   export type Outbound = SaleEventClick$Outbound;
 }
 
+export function saleEventClickToJSON(saleEventClick: SaleEventClick): string {
+  return JSON.stringify(SaleEventClick$outboundSchema.parse(saleEventClick));
+}
+
+export function saleEventClickFromJSON(
+  jsonString: string,
+): SafeParseResult<SaleEventClick, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SaleEventClick$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SaleEventClick' from JSON`,
+  );
+}
+
 /** @internal */
 export const SaleEventCustomer$inboundSchema: z.ZodType<
   SaleEventCustomer,
@@ -2199,6 +2244,24 @@ export namespace SaleEventCustomer$ {
   export type Outbound = SaleEventCustomer$Outbound;
 }
 
+export function saleEventCustomerToJSON(
+  saleEventCustomer: SaleEventCustomer,
+): string {
+  return JSON.stringify(
+    SaleEventCustomer$outboundSchema.parse(saleEventCustomer),
+  );
+}
+
+export function saleEventCustomerFromJSON(
+  jsonString: string,
+): SafeParseResult<SaleEventCustomer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SaleEventCustomer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SaleEventCustomer' from JSON`,
+  );
+}
+
 /** @internal */
 export const PaymentProcessor$inboundSchema: z.ZodNativeEnum<
   typeof PaymentProcessor
@@ -2256,6 +2319,20 @@ export namespace Sale$ {
   export type Outbound = Sale$Outbound;
 }
 
+export function saleToJSON(sale: Sale): string {
+  return JSON.stringify(Sale$outboundSchema.parse(sale));
+}
+
+export function saleFromJSON(
+  jsonString: string,
+): SafeParseResult<Sale, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Sale$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Sale' from JSON`,
+  );
+}
+
 /** @internal */
 export const SaleEvent$inboundSchema: z.ZodType<
   SaleEvent,
@@ -2374,3 +2451,17 @@ export namespace SaleEvent$ {
   /** @deprecated use `SaleEvent$Outbound` instead. */
   export type Outbound = SaleEvent$Outbound;
 }
+
+export function saleEventToJSON(saleEvent: SaleEvent): string {
+  return JSON.stringify(SaleEvent$outboundSchema.parse(saleEvent));
+}
+
+export function saleEventFromJSON(
+  jsonString: string,
+): SafeParseResult<SaleEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SaleEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SaleEvent' 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 = {
   token: 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`,
+  );
+}

package/src/models/components/tagschema.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 color of the tag.
@@ -98,3 +101,17 @@ export namespace TagSchema$ {
   /** @deprecated use `TagSchema$Outbound` instead. */
   export type Outbound = TagSchema$Outbound;
 }
+
+export function tagSchemaToJSON(tagSchema: TagSchema): string {
+  return JSON.stringify(TagSchema$outboundSchema.parse(tagSchema));
+}
+
+export function tagSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<TagSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TagSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TagSchema' from JSON`,
+  );
+}

package/src/models/components/webhookevent.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 {
   LeadCreatedEvent,
   LeadCreatedEvent$inboundSchema,
@@ -80,3 +83,17 @@ export namespace WebhookEvent$ {
   /** @deprecated use `WebhookEvent$Outbound` instead. */
   export type Outbound = WebhookEvent$Outbound;
 }
+
+export function webhookEventToJSON(webhookEvent: WebhookEvent): string {
+  return JSON.stringify(WebhookEvent$outboundSchema.parse(webhookEvent));
+}
+
+export function webhookEventFromJSON(
+  jsonString: string,
+): SafeParseResult<WebhookEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WebhookEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WebhookEvent' from JSON`,
+  );
+}

package/src/models/components/workspaceschema.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 plan of the workspace.
@@ -264,6 +267,20 @@ export namespace Users$ {
   export type Outbound = Users$Outbound;
 }
 
+export function usersToJSON(users: Users): string {
+  return JSON.stringify(Users$outboundSchema.parse(users));
+}
+
+export function usersFromJSON(
+  jsonString: string,
+): SafeParseResult<Users, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Users$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Users' from JSON`,
+  );
+}
+
 /** @internal */
 export const Domains$inboundSchema: z.ZodType<Domains, z.ZodTypeDef, unknown> =
   z.object({
@@ -303,6 +320,20 @@ export namespace Domains$ {
   export type Outbound = Domains$Outbound;
 }
 
+export function domainsToJSON(domains: Domains): string {
+  return JSON.stringify(Domains$outboundSchema.parse(domains));
+}
+
+export function domainsFromJSON(
+  jsonString: string,
+): SafeParseResult<Domains, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Domains$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Domains' from JSON`,
+  );
+}
+
 /** @internal */
 export const WorkspaceSchema$inboundSchema: z.ZodType<
   WorkspaceSchema,
@@ -434,3 +465,19 @@ export namespace WorkspaceSchema$ {
   /** @deprecated use `WorkspaceSchema$Outbound` instead. */
   export type Outbound = WorkspaceSchema$Outbound;
 }
+
+export function workspaceSchemaToJSON(
+  workspaceSchema: WorkspaceSchema,
+): string {
+  return JSON.stringify(WorkspaceSchema$outboundSchema.parse(workspaceSchema));
+}
+
+export function workspaceSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<WorkspaceSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WorkspaceSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WorkspaceSchema' from JSON`,
+  );
+}

package/src/models/errors/badrequest.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 "./sdkvalidationerror.js";
 
 /**
  * A short code indicating the error code returned.
@@ -126,6 +129,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 BadRequest$inboundSchema: z.ZodType<
   BadRequest,

package/src/models/errors/conflict.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 "./sdkvalidationerror.js";
 
 /**
  * A short code indicating the error code returned.
@@ -128,6 +131,20 @@ export namespace ConflictError$ {
   export type Outbound = ConflictError$Outbound;
 }
 
+export function conflictErrorToJSON(conflictError: ConflictError): string {
+  return JSON.stringify(ConflictError$outboundSchema.parse(conflictError));
+}
+
+export function conflictErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<ConflictError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConflictError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConflictError' from JSON`,
+  );
+}
+
 /** @internal */
 export const Conflict$inboundSchema: z.ZodType<
   Conflict,