@novu/api 3.15.0 → 3.15.1-rc.1

package/src/models/components/httprequestcontroldto.ts

@@ -18,6 +18,11 @@ import {
   HttpRequestKeyValuePairDto$outboundSchema,
 } from "./httprequestkeyvaluepairdto.js";
 
+/**
+ * Request body as a raw JSON string. Key-value arrays are supported for legacy workflows.
+ */
+export type Body = string | Array<HttpRequestKeyValuePairDto>;
+
 export type HttpRequestControlDto = {
   /**
    * HTTP method
@@ -32,9 +37,9 @@ export type HttpRequestControlDto = {
    */
   headers?: Array<HttpRequestKeyValuePairDto> | undefined;
   /**
-   * Request body as key-value pairs
+   * Request body as a raw JSON string. Key-value arrays are supported for legacy workflows.
    */
-  body?: Array<HttpRequestKeyValuePairDto> | undefined;
+  body?: string | Array<HttpRequestKeyValuePairDto> | undefined;
   /**
    * JSON schema to validate response body against
    */
@@ -49,6 +54,29 @@ export type HttpRequestControlDto = {
   continueOnFailure?: boolean | undefined;
 };
 
+/** @internal */
+export const Body$inboundSchema: z.ZodType<Body, z.ZodTypeDef, unknown> = z
+  .union([z.string(), z.array(HttpRequestKeyValuePairDto$inboundSchema)]);
+/** @internal */
+export type Body$Outbound = string | Array<HttpRequestKeyValuePairDto$Outbound>;
+
+/** @internal */
+export const Body$outboundSchema: z.ZodType<Body$Outbound, z.ZodTypeDef, Body> =
+  z.union([z.string(), z.array(HttpRequestKeyValuePairDto$outboundSchema)]);
+
+export function bodyToJSON(body: Body): string {
+  return JSON.stringify(Body$outboundSchema.parse(body));
+}
+export function bodyFromJSON(
+  jsonString: string,
+): SafeParseResult<Body, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Body$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Body' from JSON`,
+  );
+}
+
 /** @internal */
 export const HttpRequestControlDto$inboundSchema: z.ZodType<
   HttpRequestControlDto,
@@ -58,7 +86,8 @@ export const HttpRequestControlDto$inboundSchema: z.ZodType<
   method: HttpMethodEnum$inboundSchema,
   url: z.string(),
   headers: z.array(HttpRequestKeyValuePairDto$inboundSchema).optional(),
-  body: z.array(HttpRequestKeyValuePairDto$inboundSchema).optional(),
+  body: z.union([z.string(), z.array(HttpRequestKeyValuePairDto$inboundSchema)])
+    .optional(),
   responseBodySchema: z.record(z.any()).optional(),
   enforceSchemaValidation: z.boolean().optional(),
   continueOnFailure: z.boolean().optional(),
@@ -68,7 +97,7 @@ export type HttpRequestControlDto$Outbound = {
   method: string;
   url: string;
   headers?: Array<HttpRequestKeyValuePairDto$Outbound> | undefined;
-  body?: Array<HttpRequestKeyValuePairDto$Outbound> | undefined;
+  body?: string | Array<HttpRequestKeyValuePairDto$Outbound> | undefined;
   responseBodySchema?: { [k: string]: any } | undefined;
   enforceSchemaValidation?: boolean | undefined;
   continueOnFailure?: boolean | undefined;
@@ -83,7 +112,10 @@ export const HttpRequestControlDto$outboundSchema: z.ZodType<
   method: HttpMethodEnum$outboundSchema,
   url: z.string(),
   headers: z.array(HttpRequestKeyValuePairDto$outboundSchema).optional(),
-  body: z.array(HttpRequestKeyValuePairDto$outboundSchema).optional(),
+  body: z.union([
+    z.string(),
+    z.array(HttpRequestKeyValuePairDto$outboundSchema),
+  ]).optional(),
   responseBodySchema: z.record(z.any()).optional(),
   enforceSchemaValidation: z.boolean().optional(),
   continueOnFailure: z.boolean().optional(),

package/src/models/components/httprequeststepresponsedto.ts

@@ -28,6 +28,13 @@ import {
 } from "./resourceoriginenum.js";
 import { StepIssuesDto, StepIssuesDto$inboundSchema } from "./stepissuesdto.js";
 
+/**
+ * Request body as a raw JSON string. Key-value arrays are supported for legacy workflows.
+ */
+export type HttpRequestStepResponseDtoBody =
+  | string
+  | Array<HttpRequestKeyValuePairDto>;
+
 /**
  * Control values for the HTTP request step
  */
@@ -45,9 +52,9 @@ export type HttpRequestStepResponseDtoControlValues = {
    */
   headers?: Array<HttpRequestKeyValuePairDto> | undefined;
   /**
-   * Request body as key-value pairs
+   * Request body as a raw JSON string. Key-value arrays are supported for legacy workflows.
    */
-  body?: Array<HttpRequestKeyValuePairDto> | undefined;
+  body?: string | Array<HttpRequestKeyValuePairDto> | undefined;
   /**
    * JSON schema to validate response body against
    */
@@ -118,6 +125,23 @@ export type HttpRequestStepResponseDto = {
   stepResolverHash?: string | undefined;
 };
 
+/** @internal */
+export const HttpRequestStepResponseDtoBody$inboundSchema: z.ZodType<
+  HttpRequestStepResponseDtoBody,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.array(HttpRequestKeyValuePairDto$inboundSchema)]);
+
+export function httpRequestStepResponseDtoBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<HttpRequestStepResponseDtoBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => HttpRequestStepResponseDtoBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'HttpRequestStepResponseDtoBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const HttpRequestStepResponseDtoControlValues$inboundSchema: z.ZodType<
   HttpRequestStepResponseDtoControlValues,
@@ -128,7 +152,10 @@ export const HttpRequestStepResponseDtoControlValues$inboundSchema: z.ZodType<
     method: HttpMethodEnum$inboundSchema,
     url: z.string(),
     headers: z.array(HttpRequestKeyValuePairDto$inboundSchema).optional(),
-    body: z.array(HttpRequestKeyValuePairDto$inboundSchema).optional(),
+    body: z.union([
+      z.string(),
+      z.array(HttpRequestKeyValuePairDto$inboundSchema),
+    ]).optional(),
     responseBodySchema: z.record(z.any()).optional(),
     enforceSchemaValidation: z.boolean().optional(),
     continueOnFailure: z.boolean().optional(),

package/src/models/components/index.ts

@@ -42,6 +42,8 @@ export * from "./contentissueenum.js";
 export * from "./controlsmetadatadto.js";
 export * from "./createchannelconnectionrequestdto.js";
 export * from "./createcontextrequestdto.js";
+export * from "./createdomainconnectapplyurldto.js";
+export * from "./createdomaindto.js";
 export * from "./createdsubscriberdto.js";
 export * from "./createenvironmentrequestdto.js";
 export * from "./createenvironmentvariablerequestdto.js";
@@ -76,6 +78,7 @@ export * from "./deletetopicsubscriberidentifierdto.js";
 export * from "./deletetopicsubscriptionsrequestdto.js";
 export * from "./deletetopicsubscriptionsresponsedto.js";
 export * from "./dependencyreasonenum.js";
+export * from "./diagnosedomainresponsedto.js";
 export * from "./diffactionenum.js";
 export * from "./diffenvironmentrequestdto.js";
 export * from "./diffenvironmentresponsedto.js";
@@ -92,6 +95,13 @@ export * from "./digesttimedmetadata.js";
 export * from "./digesttypeenum.js";
 export * from "./digestunitenum.js";
 export * from "./directionenum.js";
+export * from "./domainconnectapplyurlresponsedto.js";
+export * from "./domainconnectstatusresponsedto.js";
+export * from "./domaindiagnosticcheckdto.js";
+export * from "./domaindiagnosticissuedto.js";
+export * from "./domainresponsedto.js";
+export * from "./domainroutedto.js";
+export * from "./domainrouteresponsedto.js";
 export * from "./duplicatelayoutdto.js";
 export * from "./emailblock.js";
 export * from "./emailblockstyles.js";
@@ -113,13 +123,16 @@ export * from "./environmentvariableworkflowinfodto.js";
 export * from "./eventbody.js";
 export * from "./executiondetailssourceenum.js";
 export * from "./executiondetailsstatusenum.js";
+export * from "./expecteddnsrecorddto.js";
 export * from "./failedoperationdto.js";
 export * from "./failedworkflowdto.js";
 export * from "./feedresponsedto.js";
 export * from "./fieldfilterpartdto.js";
 export * from "./generatechatoauthurlrequestdto.js";
 export * from "./generatechatoauthurlresponsedto.js";
+export * from "./generateconnectoauthurlrequestdto.js";
 export * from "./generatelayoutpreviewresponsedto.js";
+export * from "./generatelinkuseroauthurlrequestdto.js";
 export * from "./generatepreviewrequestdto.js";
 export * from "./generatepreviewresponsedto.js";
 export * from "./getchannelconnectionresponsedto.js";
@@ -164,6 +177,8 @@ export * from "./layoutresponsedtosortfield.js";
 export * from "./listchannelconnectionsresponsedto.js";
 export * from "./listchannelendpointsresponsedto.js";
 export * from "./listcontextsresponsedto.js";
+export * from "./listdomainroutesresponsedto.js";
+export * from "./listdomainsresponsedto.js";
 export * from "./listlayoutresponsedto.js";
 export * from "./listsubscribersresponsedto.js";
 export * from "./listtopicsresponsedto.js";
@@ -270,6 +285,11 @@ export * from "./syncedworkflowdto.js";
 export * from "./syncresultdto.js";
 export * from "./syncworkflowdto.js";
 export * from "./tenantpayloaddto.js";
+export * from "./testdomainrouteagentresultdto.js";
+export * from "./testdomainroutedto.js";
+export * from "./testdomainroutefromdto.js";
+export * from "./testdomainrouteresponsedto.js";
+export * from "./testdomainroutewebhookresultdto.js";
 export * from "./textalignenum.js";
 export * from "./throttlecontroldto.js";
 export * from "./throttlecontrolsmetadataresponsedto.js";
@@ -299,6 +319,8 @@ export * from "./updateallsubscribernotificationsdto.js";
 export * from "./updatechannelconnectionrequestdto.js";
 export * from "./updatechannelendpointrequestdto.js";
 export * from "./updatecontextrequestdto.js";
+export * from "./updatedomaindto.js";
+export * from "./updatedomainroutedto.js";
 export * from "./updatedsubscriberdto.js";
 export * from "./updateenvironmentrequestdto.js";
 export * from "./updateenvironmentvariablerequestdto.js";

package/src/models/components/listdomainroutesresponsedto.ts

@@ -0,0 +1,58 @@
+/*
+ * 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";
+import {
+  DomainRouteResponseDto,
+  DomainRouteResponseDto$inboundSchema,
+} from "./domainrouteresponsedto.js";
+
+export type ListDomainRoutesResponseDto = {
+  /**
+   * List of returned domain routes
+   */
+  data: Array<DomainRouteResponseDto>;
+  /**
+   * The cursor for the next page of results, or null if there are no more pages.
+   */
+  next: string | null;
+  /**
+   * The cursor for the previous page of results, or null if this is the first page.
+   */
+  previous: string | null;
+  /**
+   * The total count of items (up to 50,000)
+   */
+  totalCount: number;
+  /**
+   * Whether there are more than 50,000 results available
+   */
+  totalCountCapped: boolean;
+};
+
+/** @internal */
+export const ListDomainRoutesResponseDto$inboundSchema: z.ZodType<
+  ListDomainRoutesResponseDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.array(DomainRouteResponseDto$inboundSchema),
+  next: z.nullable(z.string()),
+  previous: z.nullable(z.string()),
+  totalCount: z.number(),
+  totalCountCapped: z.boolean(),
+});
+
+export function listDomainRoutesResponseDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<ListDomainRoutesResponseDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListDomainRoutesResponseDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListDomainRoutesResponseDto' from JSON`,
+  );
+}

package/src/models/components/listdomainsresponsedto.ts

@@ -0,0 +1,58 @@
+/*
+ * 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";
+import {
+  DomainResponseDto,
+  DomainResponseDto$inboundSchema,
+} from "./domainresponsedto.js";
+
+export type ListDomainsResponseDto = {
+  /**
+   * List of returned domains
+   */
+  data: Array<DomainResponseDto>;
+  /**
+   * The cursor for the next page of results, or null if there are no more pages.
+   */
+  next: string | null;
+  /**
+   * The cursor for the previous page of results, or null if this is the first page.
+   */
+  previous: string | null;
+  /**
+   * The total count of items (up to 50,000)
+   */
+  totalCount: number;
+  /**
+   * Whether there are more than 50,000 results available
+   */
+  totalCountCapped: boolean;
+};
+
+/** @internal */
+export const ListDomainsResponseDto$inboundSchema: z.ZodType<
+  ListDomainsResponseDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.array(DomainResponseDto$inboundSchema),
+  next: z.nullable(z.string()),
+  previous: z.nullable(z.string()),
+  totalCount: z.number(),
+  totalCountCapped: z.boolean(),
+});
+
+export function listDomainsResponseDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<ListDomainsResponseDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListDomainsResponseDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListDomainsResponseDto' from JSON`,
+  );
+}

package/src/models/components/providersidenum.ts

@@ -30,6 +30,7 @@ export const ProvidersIdEnum = {
   Sparkpost: "sparkpost",
   EmailWebhook: "email-webhook",
   Braze: "braze",
+  NovuEmailAgent: "novu-email-agent",
   Nexmo: "nexmo",
   Plivo: "plivo",
   Sms77: "sms77",

package/src/models/components/testdomainrouteagentresultdto.ts

@@ -0,0 +1,62 @@
+/*
+ * 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";
+
+/**
+ * Parsed JSON body from the agent webhook response when JSON.
+ */
+export type AgentReply = {};
+
+export type TestDomainRouteAgentResultDto = {
+  agentId: string;
+  httpStatus: number;
+  /**
+   * Parsed JSON body from the agent webhook response when JSON.
+   */
+  agentReply?: AgentReply | undefined;
+  latencyMs: number;
+};
+
+/** @internal */
+export const AgentReply$inboundSchema: z.ZodType<
+  AgentReply,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function agentReplyFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentReply, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentReply$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentReply' from JSON`,
+  );
+}
+
+/** @internal */
+export const TestDomainRouteAgentResultDto$inboundSchema: z.ZodType<
+  TestDomainRouteAgentResultDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  agentId: z.string(),
+  httpStatus: z.number(),
+  agentReply: z.lazy(() => AgentReply$inboundSchema).optional(),
+  latencyMs: z.number(),
+});
+
+export function testDomainRouteAgentResultDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<TestDomainRouteAgentResultDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TestDomainRouteAgentResultDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TestDomainRouteAgentResultDto' from JSON`,
+  );
+}

package/src/models/components/testdomainroutedto.ts

@@ -0,0 +1,51 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import {
+  TestDomainRouteFromDto,
+  TestDomainRouteFromDto$Outbound,
+  TestDomainRouteFromDto$outboundSchema,
+} from "./testdomainroutefromdto.js";
+
+export type TestDomainRouteDto = {
+  from: TestDomainRouteFromDto;
+  subject: string;
+  text?: string | undefined;
+  html?: string | undefined;
+  /**
+   * When true, returns the payload that would be delivered without invoking outbound webhooks or the agent HTTP endpoint.
+   */
+  dryRun?: boolean | undefined;
+};
+
+/** @internal */
+export type TestDomainRouteDto$Outbound = {
+  from: TestDomainRouteFromDto$Outbound;
+  subject: string;
+  text?: string | undefined;
+  html?: string | undefined;
+  dryRun?: boolean | undefined;
+};
+
+/** @internal */
+export const TestDomainRouteDto$outboundSchema: z.ZodType<
+  TestDomainRouteDto$Outbound,
+  z.ZodTypeDef,
+  TestDomainRouteDto
+> = z.object({
+  from: TestDomainRouteFromDto$outboundSchema,
+  subject: z.string(),
+  text: z.string().optional(),
+  html: z.string().optional(),
+  dryRun: z.boolean().optional(),
+});
+
+export function testDomainRouteDtoToJSON(
+  testDomainRouteDto: TestDomainRouteDto,
+): string {
+  return JSON.stringify(
+    TestDomainRouteDto$outboundSchema.parse(testDomainRouteDto),
+  );
+}

package/src/models/components/testdomainroutefromdto.ts

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type TestDomainRouteFromDto = {
+  address: string;
+  name?: string | undefined;
+};
+
+/** @internal */
+export type TestDomainRouteFromDto$Outbound = {
+  address: string;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const TestDomainRouteFromDto$outboundSchema: z.ZodType<
+  TestDomainRouteFromDto$Outbound,
+  z.ZodTypeDef,
+  TestDomainRouteFromDto
+> = z.object({
+  address: z.string(),
+  name: z.string().optional(),
+});
+
+export function testDomainRouteFromDtoToJSON(
+  testDomainRouteFromDto: TestDomainRouteFromDto,
+): string {
+  return JSON.stringify(
+    TestDomainRouteFromDto$outboundSchema.parse(testDomainRouteFromDto),
+  );
+}

package/src/models/components/testdomainrouteresponsedto.ts

@@ -0,0 +1,104 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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 {
+  TestDomainRouteAgentResultDto,
+  TestDomainRouteAgentResultDto$inboundSchema,
+} from "./testdomainrouteagentresultdto.js";
+import {
+  TestDomainRouteWebhookResultDto,
+  TestDomainRouteWebhookResultDto$inboundSchema,
+} from "./testdomainroutewebhookresultdto.js";
+
+export const DomainStatus = {
+  Pending: "pending",
+  Verified: "verified",
+} as const;
+export type DomainStatus = ClosedEnum<typeof DomainStatus>;
+
+export const TestDomainRouteResponseDtoType = {
+  Agent: "agent",
+  Webhook: "webhook",
+} as const;
+export type TestDomainRouteResponseDtoType = ClosedEnum<
+  typeof TestDomainRouteResponseDtoType
+>;
+
+/**
+ * The outbound payload (dry-run only).
+ */
+export type Payload = {};
+
+export type TestDomainRouteResponseDto = {
+  matched: boolean;
+  dryRun: boolean;
+  domainStatus?: DomainStatus | undefined;
+  mxRecordConfigured?: boolean | undefined;
+  type?: TestDomainRouteResponseDtoType | undefined;
+  /**
+   * Human-readable delivery target summary in dry-run mode.
+   */
+  wouldDeliverTo?: string | undefined;
+  /**
+   * The outbound payload (dry-run only).
+   */
+  payload?: Payload | undefined;
+  webhook?: TestDomainRouteWebhookResultDto | undefined;
+  agent?: TestDomainRouteAgentResultDto | undefined;
+};
+
+/** @internal */
+export const DomainStatus$inboundSchema: z.ZodNativeEnum<typeof DomainStatus> =
+  z.nativeEnum(DomainStatus);
+
+/** @internal */
+export const TestDomainRouteResponseDtoType$inboundSchema: z.ZodNativeEnum<
+  typeof TestDomainRouteResponseDtoType
+> = z.nativeEnum(TestDomainRouteResponseDtoType);
+
+/** @internal */
+export const Payload$inboundSchema: z.ZodType<Payload, z.ZodTypeDef, unknown> =
+  z.object({});
+
+export function payloadFromJSON(
+  jsonString: string,
+): SafeParseResult<Payload, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Payload$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Payload' from JSON`,
+  );
+}
+
+/** @internal */
+export const TestDomainRouteResponseDto$inboundSchema: z.ZodType<
+  TestDomainRouteResponseDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  matched: z.boolean(),
+  dryRun: z.boolean(),
+  domainStatus: DomainStatus$inboundSchema.optional(),
+  mxRecordConfigured: z.boolean().optional(),
+  type: TestDomainRouteResponseDtoType$inboundSchema.optional(),
+  wouldDeliverTo: z.string().optional(),
+  payload: z.lazy(() => Payload$inboundSchema).optional(),
+  webhook: TestDomainRouteWebhookResultDto$inboundSchema.optional(),
+  agent: TestDomainRouteAgentResultDto$inboundSchema.optional(),
+});
+
+export function testDomainRouteResponseDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<TestDomainRouteResponseDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TestDomainRouteResponseDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TestDomainRouteResponseDto' from JSON`,
+  );
+}

package/src/models/components/testdomainroutewebhookresultdto.ts

@@ -0,0 +1,36 @@
+/*
+ * 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";
+
+export type TestDomainRouteWebhookResultDto = {
+  /**
+   * True when outbound webhooks are disabled for this environment (nothing was emitted).
+   */
+  skipped?: boolean | undefined;
+  latencyMs: number;
+};
+
+/** @internal */
+export const TestDomainRouteWebhookResultDto$inboundSchema: z.ZodType<
+  TestDomainRouteWebhookResultDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  skipped: z.boolean().optional(),
+  latencyMs: z.number(),
+});
+
+export function testDomainRouteWebhookResultDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<TestDomainRouteWebhookResultDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TestDomainRouteWebhookResultDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TestDomainRouteWebhookResultDto' from JSON`,
+  );
+}

package/src/models/components/updatedomaindto.ts

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type UpdateDomainDto = {
+  /**
+   * Replaces domain metadata when provided (max 10 keys, 500 characters total for keys+values).
+   */
+  data?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export type UpdateDomainDto$Outbound = {
+  data?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const UpdateDomainDto$outboundSchema: z.ZodType<
+  UpdateDomainDto$Outbound,
+  z.ZodTypeDef,
+  UpdateDomainDto
+> = z.object({
+  data: z.record(z.string()).optional(),
+});
+
+export function updateDomainDtoToJSON(
+  updateDomainDto: UpdateDomainDto,
+): string {
+  return JSON.stringify(UpdateDomainDto$outboundSchema.parse(updateDomainDto));
+}