dub 0.45.2 → 0.45.3

package/src/models/components/clickevent.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,
@@ -602,6 +605,20 @@ export namespace Click$ {
   export type Outbound = Click$Outbound;
 }
 
+export function clickToJSON(click: Click): string {
+  return JSON.stringify(Click$outboundSchema.parse(click));
+}
+
+export function clickFromJSON(
+  jsonString: string,
+): SafeParseResult<Click, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Click$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Click' from JSON`,
+  );
+}
+
 /** @internal */
 export const ClickEventGeo$inboundSchema: z.ZodType<
   ClickEventGeo,
@@ -1891,6 +1908,20 @@ export namespace ClickEventGeo$ {
   export type Outbound = ClickEventGeo$Outbound;
 }
 
+export function clickEventGeoToJSON(clickEventGeo: ClickEventGeo): string {
+  return JSON.stringify(ClickEventGeo$outboundSchema.parse(clickEventGeo));
+}
+
+export function clickEventGeoFromJSON(
+  jsonString: string,
+): SafeParseResult<ClickEventGeo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ClickEventGeo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ClickEventGeo' from JSON`,
+  );
+}
+
 /** @internal */
 export const Link$inboundSchema: z.ZodType<Link, z.ZodTypeDef, unknown> = z
   .object({
@@ -2063,6 +2094,20 @@ export namespace Link$ {
   export type Outbound = Link$Outbound;
 }
 
+export function linkToJSON(link: Link): string {
+  return JSON.stringify(Link$outboundSchema.parse(link));
+}
+
+export function linkFromJSON(
+  jsonString: string,
+): SafeParseResult<Link, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Link$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Link' from JSON`,
+  );
+}
+
 /** @internal */
 export const ClickEvent$inboundSchema: z.ZodType<
   ClickEvent,
@@ -2156,3 +2201,17 @@ export namespace ClickEvent$ {
   /** @deprecated use `ClickEvent$Outbound` instead. */
   export type Outbound = ClickEvent$Outbound;
 }
+
+export function clickEventToJSON(clickEvent: ClickEvent): string {
+  return JSON.stringify(ClickEvent$outboundSchema.parse(clickEvent));
+}
+
+export function clickEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ClickEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ClickEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ClickEvent' from JSON`,
+  );
+}

package/src/models/components/domainschema.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 registered domain record.
@@ -111,6 +114,24 @@ export namespace RegisteredDomain$ {
   export type Outbound = RegisteredDomain$Outbound;
 }
 
+export function registeredDomainToJSON(
+  registeredDomain: RegisteredDomain,
+): string {
+  return JSON.stringify(
+    RegisteredDomain$outboundSchema.parse(registeredDomain),
+  );
+}
+
+export function registeredDomainFromJSON(
+  jsonString: string,
+): SafeParseResult<RegisteredDomain, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RegisteredDomain$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RegisteredDomain' from JSON`,
+  );
+}
+
 /** @internal */
 export const DomainSchema$inboundSchema: z.ZodType<
   DomainSchema,
@@ -176,3 +197,17 @@ export namespace DomainSchema$ {
   /** @deprecated use `DomainSchema$Outbound` instead. */
   export type Outbound = DomainSchema$Outbound;
 }
+
+export function domainSchemaToJSON(domainSchema: DomainSchema): string {
+  return JSON.stringify(DomainSchema$outboundSchema.parse(domainSchema));
+}
+
+export function domainSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<DomainSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DomainSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainSchema' from JSON`,
+  );
+}

package/src/models/components/leadcreatedevent.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,
@@ -547,6 +550,24 @@ export namespace LeadCreatedEventCustomer$ {
   export type Outbound = LeadCreatedEventCustomer$Outbound;
 }
 
+export function leadCreatedEventCustomerToJSON(
+  leadCreatedEventCustomer: LeadCreatedEventCustomer,
+): string {
+  return JSON.stringify(
+    LeadCreatedEventCustomer$outboundSchema.parse(leadCreatedEventCustomer),
+  );
+}
+
+export function leadCreatedEventCustomerFromJSON(
+  jsonString: string,
+): SafeParseResult<LeadCreatedEventCustomer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LeadCreatedEventCustomer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LeadCreatedEventCustomer' from JSON`,
+  );
+}
+
 /** @internal */
 export const LeadCreatedEventClick$inboundSchema: z.ZodType<
   LeadCreatedEventClick,
@@ -616,6 +637,24 @@ export namespace LeadCreatedEventClick$ {
   export type Outbound = LeadCreatedEventClick$Outbound;
 }
 
+export function leadCreatedEventClickToJSON(
+  leadCreatedEventClick: LeadCreatedEventClick,
+): string {
+  return JSON.stringify(
+    LeadCreatedEventClick$outboundSchema.parse(leadCreatedEventClick),
+  );
+}
+
+export function leadCreatedEventClickFromJSON(
+  jsonString: string,
+): SafeParseResult<LeadCreatedEventClick, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LeadCreatedEventClick$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LeadCreatedEventClick' from JSON`,
+  );
+}
+
 /** @internal */
 export const LeadCreatedEventGeo$inboundSchema: z.ZodType<
   LeadCreatedEventGeo,
@@ -1905,6 +1944,24 @@ export namespace LeadCreatedEventGeo$ {
   export type Outbound = LeadCreatedEventGeo$Outbound;
 }
 
+export function leadCreatedEventGeoToJSON(
+  leadCreatedEventGeo: LeadCreatedEventGeo,
+): string {
+  return JSON.stringify(
+    LeadCreatedEventGeo$outboundSchema.parse(leadCreatedEventGeo),
+  );
+}
+
+export function leadCreatedEventGeoFromJSON(
+  jsonString: string,
+): SafeParseResult<LeadCreatedEventGeo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LeadCreatedEventGeo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LeadCreatedEventGeo' from JSON`,
+  );
+}
+
 /** @internal */
 export const LeadCreatedEventLink$inboundSchema: z.ZodType<
   LeadCreatedEventLink,
@@ -2083,6 +2140,24 @@ export namespace LeadCreatedEventLink$ {
   export type Outbound = LeadCreatedEventLink$Outbound;
 }
 
+export function leadCreatedEventLinkToJSON(
+  leadCreatedEventLink: LeadCreatedEventLink,
+): string {
+  return JSON.stringify(
+    LeadCreatedEventLink$outboundSchema.parse(leadCreatedEventLink),
+  );
+}
+
+export function leadCreatedEventLinkFromJSON(
+  jsonString: string,
+): SafeParseResult<LeadCreatedEventLink, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LeadCreatedEventLink$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LeadCreatedEventLink' from JSON`,
+  );
+}
+
 /** @internal */
 export const LeadCreatedEventData$inboundSchema: z.ZodType<
   LeadCreatedEventData,
@@ -2128,6 +2203,24 @@ export namespace LeadCreatedEventData$ {
   export type Outbound = LeadCreatedEventData$Outbound;
 }
 
+export function leadCreatedEventDataToJSON(
+  leadCreatedEventData: LeadCreatedEventData,
+): string {
+  return JSON.stringify(
+    LeadCreatedEventData$outboundSchema.parse(leadCreatedEventData),
+  );
+}
+
+export function leadCreatedEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<LeadCreatedEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LeadCreatedEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LeadCreatedEventData' from JSON`,
+  );
+}
+
 /** @internal */
 export const LeadCreatedEvent$inboundSchema: z.ZodType<
   LeadCreatedEvent,
@@ -2172,3 +2265,21 @@ export namespace LeadCreatedEvent$ {
   /** @deprecated use `LeadCreatedEvent$Outbound` instead. */
   export type Outbound = LeadCreatedEvent$Outbound;
 }
+
+export function leadCreatedEventToJSON(
+  leadCreatedEvent: LeadCreatedEvent,
+): string {
+  return JSON.stringify(
+    LeadCreatedEvent$outboundSchema.parse(leadCreatedEvent),
+  );
+}
+
+export function leadCreatedEventFromJSON(
+  jsonString: string,
+): SafeParseResult<LeadCreatedEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LeadCreatedEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LeadCreatedEvent' from JSON`,
+  );
+}

package/src/models/components/leadevent.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,
@@ -636,6 +639,20 @@ export namespace LeadEventClick$ {
   export type Outbound = LeadEventClick$Outbound;
 }
 
+export function leadEventClickToJSON(leadEventClick: LeadEventClick): string {
+  return JSON.stringify(LeadEventClick$outboundSchema.parse(leadEventClick));
+}
+
+export function leadEventClickFromJSON(
+  jsonString: string,
+): SafeParseResult<LeadEventClick, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LeadEventClick$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LeadEventClick' from JSON`,
+  );
+}
+
 /** @internal */
 export const LeadEventGeo$inboundSchema: z.ZodType<
   LeadEventGeo,
@@ -1925,6 +1942,20 @@ export namespace LeadEventGeo$ {
   export type Outbound = LeadEventGeo$Outbound;
 }
 
+export function leadEventGeoToJSON(leadEventGeo: LeadEventGeo): string {
+  return JSON.stringify(LeadEventGeo$outboundSchema.parse(leadEventGeo));
+}
+
+export function leadEventGeoFromJSON(
+  jsonString: string,
+): SafeParseResult<LeadEventGeo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LeadEventGeo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LeadEventGeo' from JSON`,
+  );
+}
+
 /** @internal */
 export const LeadEventLink$inboundSchema: z.ZodType<
   LeadEventLink,
@@ -2103,6 +2134,20 @@ export namespace LeadEventLink$ {
   export type Outbound = LeadEventLink$Outbound;
 }
 
+export function leadEventLinkToJSON(leadEventLink: LeadEventLink): string {
+  return JSON.stringify(LeadEventLink$outboundSchema.parse(leadEventLink));
+}
+
+export function leadEventLinkFromJSON(
+  jsonString: string,
+): SafeParseResult<LeadEventLink, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LeadEventLink$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LeadEventLink' from JSON`,
+  );
+}
+
 /** @internal */
 export const Customer$inboundSchema: z.ZodType<
   Customer,
@@ -2154,6 +2199,20 @@ export namespace Customer$ {
   export type Outbound = Customer$Outbound;
 }
 
+export function customerToJSON(customer: Customer): string {
+  return JSON.stringify(Customer$outboundSchema.parse(customer));
+}
+
+export function customerFromJSON(
+  jsonString: string,
+): SafeParseResult<Customer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Customer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Customer' from JSON`,
+  );
+}
+
 /** @internal */
 export const LeadEvent$inboundSchema: z.ZodType<
   LeadEvent,
@@ -2256,3 +2315,17 @@ export namespace LeadEvent$ {
   /** @deprecated use `LeadEvent$Outbound` instead. */
   export type Outbound = LeadEvent$Outbound;
 }
+
+export function leadEventToJSON(leadEvent: LeadEvent): string {
+  return JSON.stringify(LeadEvent$outboundSchema.parse(leadEvent));
+}
+
+export function leadEventFromJSON(
+  jsonString: string,
+): SafeParseResult<LeadEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LeadEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LeadEvent' from JSON`,
+  );
+}

package/src/models/components/linkclickedevent.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,
@@ -536,6 +539,24 @@ export namespace LinkClickedEventClick$ {
   export type Outbound = LinkClickedEventClick$Outbound;
 }
 
+export function linkClickedEventClickToJSON(
+  linkClickedEventClick: LinkClickedEventClick,
+): string {
+  return JSON.stringify(
+    LinkClickedEventClick$outboundSchema.parse(linkClickedEventClick),
+  );
+}
+
+export function linkClickedEventClickFromJSON(
+  jsonString: string,
+): SafeParseResult<LinkClickedEventClick, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LinkClickedEventClick$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LinkClickedEventClick' from JSON`,
+  );
+}
+
 /** @internal */
 export const LinkClickedEventGeo$inboundSchema: z.ZodType<
   LinkClickedEventGeo,
@@ -1825,6 +1846,24 @@ export namespace LinkClickedEventGeo$ {
   export type Outbound = LinkClickedEventGeo$Outbound;
 }
 
+export function linkClickedEventGeoToJSON(
+  linkClickedEventGeo: LinkClickedEventGeo,
+): string {
+  return JSON.stringify(
+    LinkClickedEventGeo$outboundSchema.parse(linkClickedEventGeo),
+  );
+}
+
+export function linkClickedEventGeoFromJSON(
+  jsonString: string,
+): SafeParseResult<LinkClickedEventGeo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LinkClickedEventGeo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LinkClickedEventGeo' from JSON`,
+  );
+}
+
 /** @internal */
 export const LinkClickedEventLink$inboundSchema: z.ZodType<
   LinkClickedEventLink,
@@ -2003,6 +2042,24 @@ export namespace LinkClickedEventLink$ {
   export type Outbound = LinkClickedEventLink$Outbound;
 }
 
+export function linkClickedEventLinkToJSON(
+  linkClickedEventLink: LinkClickedEventLink,
+): string {
+  return JSON.stringify(
+    LinkClickedEventLink$outboundSchema.parse(linkClickedEventLink),
+  );
+}
+
+export function linkClickedEventLinkFromJSON(
+  jsonString: string,
+): SafeParseResult<LinkClickedEventLink, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LinkClickedEventLink$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LinkClickedEventLink' from JSON`,
+  );
+}
+
 /** @internal */
 export const LinkClickedEventData$inboundSchema: z.ZodType<
   LinkClickedEventData,
@@ -2042,6 +2099,24 @@ export namespace LinkClickedEventData$ {
   export type Outbound = LinkClickedEventData$Outbound;
 }
 
+export function linkClickedEventDataToJSON(
+  linkClickedEventData: LinkClickedEventData,
+): string {
+  return JSON.stringify(
+    LinkClickedEventData$outboundSchema.parse(linkClickedEventData),
+  );
+}
+
+export function linkClickedEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<LinkClickedEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LinkClickedEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LinkClickedEventData' from JSON`,
+  );
+}
+
 /** @internal */
 export const LinkClickedEvent$inboundSchema: z.ZodType<
   LinkClickedEvent,
@@ -2086,3 +2161,21 @@ export namespace LinkClickedEvent$ {
   /** @deprecated use `LinkClickedEvent$Outbound` instead. */
   export type Outbound = LinkClickedEvent$Outbound;
 }
+
+export function linkClickedEventToJSON(
+  linkClickedEvent: LinkClickedEvent,
+): string {
+  return JSON.stringify(
+    LinkClickedEvent$outboundSchema.parse(linkClickedEvent),
+  );
+}
+
+export function linkClickedEventFromJSON(
+  jsonString: string,
+): SafeParseResult<LinkClickedEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LinkClickedEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LinkClickedEvent' from JSON`,
+  );
+}

package/src/models/components/linkgeotargeting.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";
 
 /**
  * Geo targeting information for the short link in JSON format `{[COUNTRY]: https://example.com }`.
@@ -1549,3 +1552,21 @@ export namespace LinkGeoTargeting$ {
   /** @deprecated use `LinkGeoTargeting$Outbound` instead. */
   export type Outbound = LinkGeoTargeting$Outbound;
 }
+
+export function linkGeoTargetingToJSON(
+  linkGeoTargeting: LinkGeoTargeting,
+): string {
+  return JSON.stringify(
+    LinkGeoTargeting$outboundSchema.parse(linkGeoTargeting),
+  );
+}
+
+export function linkGeoTargetingFromJSON(
+  jsonString: string,
+): SafeParseResult<LinkGeoTargeting, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LinkGeoTargeting$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LinkGeoTargeting' from JSON`,
+  );
+}

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`,
+  );
+}