@unified-api/typescript-sdk 2.83.18 → 2.83.20

package/src/sdk/models/shared/atsmetadata.ts

@@ -10,16 +10,16 @@ import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export type AtsMetadata1 = {};
+export type One = {};
 
-export type AtsMetadata5 = AtsMetadata1 | string | number | boolean;
+export type Five = One | string | number | boolean;
 
 export type ExtraData =
   | { [k: string]: any }
   | string
   | number
   | boolean
-  | Array<AtsMetadata1 | string | number | boolean>;
+  | Array<One | string | number | boolean>;
 
 export const Format = {
   Text: "TEXT",
@@ -38,20 +38,16 @@ export const Format = {
 } as const;
 export type Format = OpenEnum<typeof Format>;
 
-export type AtsMetadataSchemas1 = {};
+export type AtsMetadata1 = {};
 
-export type AtsMetadataSchemas5 =
-  | AtsMetadataSchemas1
-  | string
-  | number
-  | boolean;
+export type AtsMetadata5 = AtsMetadata1 | string | number | boolean;
 
-export type AtsMetadataValue =
+export type Value =
   | { [k: string]: any }
   | string
   | number
   | boolean
-  | Array<AtsMetadataSchemas1 | string | number | boolean>;
+  | Array<AtsMetadata1 | string | number | boolean>;
 
 export type AtsMetadata = {
   extraData?:
@@ -59,7 +55,7 @@ export type AtsMetadata = {
     | string
     | number
     | boolean
-    | Array<AtsMetadata1 | string | number | boolean>
+    | Array<One | string | number | boolean>
     | undefined;
   format?: Format | undefined;
   id?: string | undefined;
@@ -70,79 +66,63 @@ export type AtsMetadata = {
     | string
     | number
     | boolean
-    | Array<AtsMetadataSchemas1 | string | number | boolean>
+    | Array<AtsMetadata1 | string | number | boolean>
     | undefined;
 };
 
 /** @internal */
-export const AtsMetadata1$inboundSchema: z.ZodType<
-  AtsMetadata1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
+export const One$inboundSchema: z.ZodType<One, z.ZodTypeDef, unknown> = z
+  .object({});
 /** @internal */
-export type AtsMetadata1$Outbound = {};
+export type One$Outbound = {};
 
 /** @internal */
-export const AtsMetadata1$outboundSchema: z.ZodType<
-  AtsMetadata1$Outbound,
-  z.ZodTypeDef,
-  AtsMetadata1
-> = z.object({});
+export const One$outboundSchema: z.ZodType<One$Outbound, z.ZodTypeDef, One> = z
+  .object({});
 
-export function atsMetadata1ToJSON(atsMetadata1: AtsMetadata1): string {
-  return JSON.stringify(AtsMetadata1$outboundSchema.parse(atsMetadata1));
+export function oneToJSON(one: One): string {
+  return JSON.stringify(One$outboundSchema.parse(one));
 }
-export function atsMetadata1FromJSON(
+export function oneFromJSON(
   jsonString: string,
-): SafeParseResult<AtsMetadata1, SDKValidationError> {
+): SafeParseResult<One, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AtsMetadata1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AtsMetadata1' from JSON`,
+    (x) => One$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'One' from JSON`,
   );
 }
 
 /** @internal */
-export const AtsMetadata5$inboundSchema: z.ZodType<
-  AtsMetadata5,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => AtsMetadata1$inboundSchema),
-  z.string(),
-  z.number(),
-  z.boolean(),
-]);
+export const Five$inboundSchema: z.ZodType<Five, z.ZodTypeDef, unknown> = z
+  .union([
+    z.lazy(() => One$inboundSchema),
+    z.string(),
+    z.number(),
+    z.boolean(),
+  ]);
 /** @internal */
-export type AtsMetadata5$Outbound =
-  | AtsMetadata1$Outbound
-  | string
-  | number
-  | boolean;
+export type Five$Outbound = One$Outbound | string | number | boolean;
 
 /** @internal */
-export const AtsMetadata5$outboundSchema: z.ZodType<
-  AtsMetadata5$Outbound,
-  z.ZodTypeDef,
-  AtsMetadata5
-> = z.union([
-  z.lazy(() => AtsMetadata1$outboundSchema),
-  z.string(),
-  z.number(),
-  z.boolean(),
-]);
+export const Five$outboundSchema: z.ZodType<Five$Outbound, z.ZodTypeDef, Five> =
+  z.union([
+    z.lazy(() => One$outboundSchema),
+    z.string(),
+    z.number(),
+    z.boolean(),
+  ]);
 
-export function atsMetadata5ToJSON(atsMetadata5: AtsMetadata5): string {
-  return JSON.stringify(AtsMetadata5$outboundSchema.parse(atsMetadata5));
+export function fiveToJSON(five: Five): string {
+  return JSON.stringify(Five$outboundSchema.parse(five));
 }
-export function atsMetadata5FromJSON(
+export function fiveFromJSON(
   jsonString: string,
-): SafeParseResult<AtsMetadata5, SDKValidationError> {
+): SafeParseResult<Five, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AtsMetadata5$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AtsMetadata5' from JSON`,
+    (x) => Five$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Five' from JSON`,
   );
 }
 
@@ -158,7 +138,7 @@ export const ExtraData$inboundSchema: z.ZodType<
   z.boolean(),
   z.array(
     z.union([
-      z.lazy(() => AtsMetadata1$inboundSchema),
+      z.lazy(() => One$inboundSchema),
       z.string(),
       z.number(),
       z.boolean(),
@@ -171,7 +151,7 @@ export type ExtraData$Outbound =
   | string
   | number
   | boolean
-  | Array<AtsMetadata1$Outbound | string | number | boolean>;
+  | Array<One$Outbound | string | number | boolean>;
 
 /** @internal */
 export const ExtraData$outboundSchema: z.ZodType<
@@ -185,7 +165,7 @@ export const ExtraData$outboundSchema: z.ZodType<
   z.boolean(),
   z.array(
     z.union([
-      z.lazy(() => AtsMetadata1$outboundSchema),
+      z.lazy(() => One$outboundSchema),
       z.string(),
       z.number(),
       z.boolean(),
@@ -214,117 +194,106 @@ export const Format$outboundSchema: z.ZodType<string, z.ZodTypeDef, Format> =
   openEnums.outboundSchema(Format);
 
 /** @internal */
-export const AtsMetadataSchemas1$inboundSchema: z.ZodType<
-  AtsMetadataSchemas1,
+export const AtsMetadata1$inboundSchema: z.ZodType<
+  AtsMetadata1,
   z.ZodTypeDef,
   unknown
 > = z.object({});
 /** @internal */
-export type AtsMetadataSchemas1$Outbound = {};
+export type AtsMetadata1$Outbound = {};
 
 /** @internal */
-export const AtsMetadataSchemas1$outboundSchema: z.ZodType<
-  AtsMetadataSchemas1$Outbound,
+export const AtsMetadata1$outboundSchema: z.ZodType<
+  AtsMetadata1$Outbound,
   z.ZodTypeDef,
-  AtsMetadataSchemas1
+  AtsMetadata1
 > = z.object({});
 
-export function atsMetadataSchemas1ToJSON(
-  atsMetadataSchemas1: AtsMetadataSchemas1,
-): string {
-  return JSON.stringify(
-    AtsMetadataSchemas1$outboundSchema.parse(atsMetadataSchemas1),
-  );
+export function atsMetadata1ToJSON(atsMetadata1: AtsMetadata1): string {
+  return JSON.stringify(AtsMetadata1$outboundSchema.parse(atsMetadata1));
 }
-export function atsMetadataSchemas1FromJSON(
+export function atsMetadata1FromJSON(
   jsonString: string,
-): SafeParseResult<AtsMetadataSchemas1, SDKValidationError> {
+): SafeParseResult<AtsMetadata1, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AtsMetadataSchemas1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AtsMetadataSchemas1' from JSON`,
+    (x) => AtsMetadata1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AtsMetadata1' from JSON`,
   );
 }
 
 /** @internal */
-export const AtsMetadataSchemas5$inboundSchema: z.ZodType<
-  AtsMetadataSchemas5,
+export const AtsMetadata5$inboundSchema: z.ZodType<
+  AtsMetadata5,
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => AtsMetadataSchemas1$inboundSchema),
+  z.lazy(() => AtsMetadata1$inboundSchema),
   z.string(),
   z.number(),
   z.boolean(),
 ]);
 /** @internal */
-export type AtsMetadataSchemas5$Outbound =
-  | AtsMetadataSchemas1$Outbound
+export type AtsMetadata5$Outbound =
+  | AtsMetadata1$Outbound
   | string
   | number
   | boolean;
 
 /** @internal */
-export const AtsMetadataSchemas5$outboundSchema: z.ZodType<
-  AtsMetadataSchemas5$Outbound,
+export const AtsMetadata5$outboundSchema: z.ZodType<
+  AtsMetadata5$Outbound,
   z.ZodTypeDef,
-  AtsMetadataSchemas5
+  AtsMetadata5
 > = z.union([
-  z.lazy(() => AtsMetadataSchemas1$outboundSchema),
+  z.lazy(() => AtsMetadata1$outboundSchema),
   z.string(),
   z.number(),
   z.boolean(),
 ]);
 
-export function atsMetadataSchemas5ToJSON(
-  atsMetadataSchemas5: AtsMetadataSchemas5,
-): string {
-  return JSON.stringify(
-    AtsMetadataSchemas5$outboundSchema.parse(atsMetadataSchemas5),
-  );
+export function atsMetadata5ToJSON(atsMetadata5: AtsMetadata5): string {
+  return JSON.stringify(AtsMetadata5$outboundSchema.parse(atsMetadata5));
 }
-export function atsMetadataSchemas5FromJSON(
+export function atsMetadata5FromJSON(
   jsonString: string,
-): SafeParseResult<AtsMetadataSchemas5, SDKValidationError> {
+): SafeParseResult<AtsMetadata5, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AtsMetadataSchemas5$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AtsMetadataSchemas5' from JSON`,
+    (x) => AtsMetadata5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AtsMetadata5' from JSON`,
   );
 }
 
 /** @internal */
-export const AtsMetadataValue$inboundSchema: z.ZodType<
-  AtsMetadataValue,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.record(z.any()),
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.array(
-    z.union([
-      z.lazy(() => AtsMetadataSchemas1$inboundSchema),
-      z.string(),
-      z.number(),
-      z.boolean(),
-    ]),
-  ),
-]);
+export const Value$inboundSchema: z.ZodType<Value, z.ZodTypeDef, unknown> = z
+  .union([
+    z.record(z.any()),
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(
+      z.union([
+        z.lazy(() => AtsMetadata1$inboundSchema),
+        z.string(),
+        z.number(),
+        z.boolean(),
+      ]),
+    ),
+  ]);
 /** @internal */
-export type AtsMetadataValue$Outbound =
+export type Value$Outbound =
   | { [k: string]: any }
   | string
   | number
   | boolean
-  | Array<AtsMetadataSchemas1$Outbound | string | number | boolean>;
+  | Array<AtsMetadata1$Outbound | string | number | boolean>;
 
 /** @internal */
-export const AtsMetadataValue$outboundSchema: z.ZodType<
-  AtsMetadataValue$Outbound,
+export const Value$outboundSchema: z.ZodType<
+  Value$Outbound,
   z.ZodTypeDef,
-  AtsMetadataValue
+  Value
 > = z.union([
   z.record(z.any()),
   z.string(),
@@ -332,7 +301,7 @@ export const AtsMetadataValue$outboundSchema: z.ZodType<
   z.boolean(),
   z.array(
     z.union([
-      z.lazy(() => AtsMetadataSchemas1$outboundSchema),
+      z.lazy(() => AtsMetadata1$outboundSchema),
       z.string(),
       z.number(),
       z.boolean(),
@@ -340,20 +309,16 @@ export const AtsMetadataValue$outboundSchema: z.ZodType<
   ),
 ]);
 
-export function atsMetadataValueToJSON(
-  atsMetadataValue: AtsMetadataValue,
-): string {
-  return JSON.stringify(
-    AtsMetadataValue$outboundSchema.parse(atsMetadataValue),
-  );
+export function valueToJSON(value: Value): string {
+  return JSON.stringify(Value$outboundSchema.parse(value));
 }
-export function atsMetadataValueFromJSON(
+export function valueFromJSON(
   jsonString: string,
-): SafeParseResult<AtsMetadataValue, SDKValidationError> {
+): SafeParseResult<Value, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AtsMetadataValue$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AtsMetadataValue' from JSON`,
+    (x) => Value$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Value' from JSON`,
   );
 }
 
@@ -370,7 +335,7 @@ export const AtsMetadata$inboundSchema: z.ZodType<
     z.boolean(),
     z.array(
       z.union([
-        z.lazy(() => AtsMetadata1$inboundSchema),
+        z.lazy(() => One$inboundSchema),
         z.string(),
         z.number(),
         z.boolean(),
@@ -388,7 +353,7 @@ export const AtsMetadata$inboundSchema: z.ZodType<
     z.boolean(),
     z.array(
       z.union([
-        z.lazy(() => AtsMetadataSchemas1$inboundSchema),
+        z.lazy(() => AtsMetadata1$inboundSchema),
         z.string(),
         z.number(),
         z.boolean(),
@@ -407,7 +372,7 @@ export type AtsMetadata$Outbound = {
     | string
     | number
     | boolean
-    | Array<AtsMetadata1$Outbound | string | number | boolean>
+    | Array<One$Outbound | string | number | boolean>
     | undefined;
   format?: string | undefined;
   id?: string | undefined;
@@ -418,7 +383,7 @@ export type AtsMetadata$Outbound = {
     | string
     | number
     | boolean
-    | Array<AtsMetadataSchemas1$Outbound | string | number | boolean>
+    | Array<AtsMetadata1$Outbound | string | number | boolean>
     | undefined;
 };
 
@@ -435,7 +400,7 @@ export const AtsMetadata$outboundSchema: z.ZodType<
     z.boolean(),
     z.array(
       z.union([
-        z.lazy(() => AtsMetadata1$outboundSchema),
+        z.lazy(() => One$outboundSchema),
         z.string(),
         z.number(),
         z.boolean(),
@@ -453,7 +418,7 @@ export const AtsMetadata$outboundSchema: z.ZodType<
     z.boolean(),
     z.array(
       z.union([
-        z.lazy(() => AtsMetadataSchemas1$outboundSchema),
+        z.lazy(() => AtsMetadata1$outboundSchema),
         z.string(),
         z.number(),
         z.boolean(),

package/src/sdk/models/shared/audiencecombination.ts

@@ -0,0 +1,78 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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 {
+  AudienceSegment,
+  AudienceSegment$inboundSchema,
+  AudienceSegment$Outbound,
+  AudienceSegment$outboundSchema,
+} from "./audiencesegment.js";
+
+export type AudienceCombination = {
+  behaviors?: Array<AudienceSegment> | undefined;
+  demographics?: Array<AudienceSegment> | undefined;
+  interests?: Array<AudienceSegment> | undefined;
+  lifeEvents?: Array<AudienceSegment> | undefined;
+};
+
+/** @internal */
+export const AudienceCombination$inboundSchema: z.ZodType<
+  AudienceCombination,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  behaviors: z.array(AudienceSegment$inboundSchema).optional(),
+  demographics: z.array(AudienceSegment$inboundSchema).optional(),
+  interests: z.array(AudienceSegment$inboundSchema).optional(),
+  life_events: z.array(AudienceSegment$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "life_events": "lifeEvents",
+  });
+});
+/** @internal */
+export type AudienceCombination$Outbound = {
+  behaviors?: Array<AudienceSegment$Outbound> | undefined;
+  demographics?: Array<AudienceSegment$Outbound> | undefined;
+  interests?: Array<AudienceSegment$Outbound> | undefined;
+  life_events?: Array<AudienceSegment$Outbound> | undefined;
+};
+
+/** @internal */
+export const AudienceCombination$outboundSchema: z.ZodType<
+  AudienceCombination$Outbound,
+  z.ZodTypeDef,
+  AudienceCombination
+> = z.object({
+  behaviors: z.array(AudienceSegment$outboundSchema).optional(),
+  demographics: z.array(AudienceSegment$outboundSchema).optional(),
+  interests: z.array(AudienceSegment$outboundSchema).optional(),
+  lifeEvents: z.array(AudienceSegment$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    lifeEvents: "life_events",
+  });
+});
+
+export function audienceCombinationToJSON(
+  audienceCombination: AudienceCombination,
+): string {
+  return JSON.stringify(
+    AudienceCombination$outboundSchema.parse(audienceCombination),
+  );
+}
+export function audienceCombinationFromJSON(
+  jsonString: string,
+): SafeParseResult<AudienceCombination, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AudienceCombination$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AudienceCombination' from JSON`,
+  );
+}

package/src/sdk/models/shared/audiencesegment.ts

@@ -0,0 +1,56 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Audience targeting (Meta: custom_audiences, lookalike_audiences, flexible_spec)
+ */
+export type AudienceSegment = {
+  id: string;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const AudienceSegment$inboundSchema: z.ZodType<
+  AudienceSegment,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+});
+/** @internal */
+export type AudienceSegment$Outbound = {
+  id: string;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const AudienceSegment$outboundSchema: z.ZodType<
+  AudienceSegment$Outbound,
+  z.ZodTypeDef,
+  AudienceSegment
+> = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+});
+
+export function audienceSegmentToJSON(
+  audienceSegment: AudienceSegment,
+): string {
+  return JSON.stringify(AudienceSegment$outboundSchema.parse(audienceSegment));
+}
+export function audienceSegmentFromJSON(
+  jsonString: string,
+): SafeParseResult<AudienceSegment, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AudienceSegment$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AudienceSegment' from JSON`,
+  );
+}

package/src/sdk/models/shared/citytarget.ts

@@ -0,0 +1,89 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const RadiusUnit = {
+  Miles: "MILES",
+  Kilometers: "KILOMETERS",
+} as const;
+export type RadiusUnit = OpenEnum<typeof RadiusUnit>;
+
+export type CityTarget = {
+  id: string;
+  name?: string | undefined;
+  radius?: number | undefined;
+  radiusUnit?: RadiusUnit | undefined;
+};
+
+/** @internal */
+export const RadiusUnit$inboundSchema: z.ZodType<
+  RadiusUnit,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(RadiusUnit);
+/** @internal */
+export const RadiusUnit$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  RadiusUnit
+> = openEnums.outboundSchema(RadiusUnit);
+
+/** @internal */
+export const CityTarget$inboundSchema: z.ZodType<
+  CityTarget,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  radius: z.number().optional(),
+  radius_unit: RadiusUnit$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "radius_unit": "radiusUnit",
+  });
+});
+/** @internal */
+export type CityTarget$Outbound = {
+  id: string;
+  name?: string | undefined;
+  radius?: number | undefined;
+  radius_unit?: string | undefined;
+};
+
+/** @internal */
+export const CityTarget$outboundSchema: z.ZodType<
+  CityTarget$Outbound,
+  z.ZodTypeDef,
+  CityTarget
+> = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  radius: z.number().optional(),
+  radiusUnit: RadiusUnit$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    radiusUnit: "radius_unit",
+  });
+});
+
+export function cityTargetToJSON(cityTarget: CityTarget): string {
+  return JSON.stringify(CityTarget$outboundSchema.parse(cityTarget));
+}
+export function cityTargetFromJSON(
+  jsonString: string,
+): SafeParseResult<CityTarget, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CityTarget$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CityTarget' from JSON`,
+  );
+}