@novu/api 3.15.0 → 3.15.1-rc.1

package/src/funcs/workflowsUpdate.ts

@@ -4,6 +4,7 @@
 
 import { NovuCore } from "../core.js";
 import { encodeJSON, encodeSimple } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
 import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
@@ -168,23 +169,8 @@ async function $do(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: [
-      "400",
-      "401",
-      "403",
-      "404",
-      "405",
-      "409",
-      "413",
-      "414",
-      "415",
-      "422",
-      "429",
-      "4XX",
-      "500",
-      "503",
-      "5XX",
-    ],
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });

package/src/lib/config.ts

@@ -59,7 +59,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "3.15.0",
-  sdkVersion: "3.15.0",
-  genVersion: "2.879.11",
-  userAgent: "speakeasy-sdk/typescript 3.15.0 2.879.11 3.15.0 @novu/api",
+  sdkVersion: "3.15.1-rc.1",
+  genVersion: "2.881.4",
+  userAgent: "speakeasy-sdk/typescript 3.15.1-rc.1 2.881.4 3.15.0 @novu/api",
 } as const;

package/src/lib/sdks.ts

@@ -21,7 +21,6 @@ import {
   isConnectionError,
   isTimeoutError,
   matchContentType,
-  matchStatusCode,
 } from "./http.js";
 import { Logger } from "./logger.js";
 import { retry, RetryConfig } from "./retries.js";
@@ -230,7 +229,7 @@ export class ClientSDK {
     request: Request,
     options: {
       context: HookContext;
-      errorCodes: number | string | (number | string)[];
+      isErrorStatusCode: (statusCode: number) => boolean;
       retryConfig: RetryConfig;
       retryCodes: string[];
     },
@@ -243,7 +242,7 @@ export class ClientSDK {
       | UnexpectedClientError
     >
   > {
-    const { context, errorCodes } = options;
+    const { context, isErrorStatusCode } = options;
 
     return retry(
       async () => {
@@ -255,7 +254,7 @@ export class ClientSDK {
         let response = await this.#httpClient.request(req);
 
         try {
-          if (matchStatusCode(response, errorCodes)) {
+          if (isErrorStatusCode(response.status)) {
             const result = await this.#hooks.afterError(
               context,
               response,
@@ -379,8 +378,6 @@ async function logResponse(
       break;
     case matchContentType(res, "application/jsonl")
       || jsonlLikeContentTypeRE.test(ct):
-      logger.log(await res.clone().text());
-      break;
     case matchContentType(res, "text/event-stream"):
       logger.log(`<${contentType}>`);
       break;

package/src/models/components/activitynotificationjobresponsedto.ts

@@ -51,7 +51,7 @@ export type ActivityNotificationJobResponseDtoType = ClosedEnum<
 /**
  * Optional payload for the job
  */
-export type Payload = {};
+export type ActivityNotificationJobResponseDtoPayload = {};
 
 export type ActivityNotificationJobResponseDto = {
   /**
@@ -81,7 +81,7 @@ export type ActivityNotificationJobResponseDto = {
   /**
    * Optional payload for the job
    */
-  payload?: Payload | undefined;
+  payload?: ActivityNotificationJobResponseDtoPayload | undefined;
   /**
    * Provider ID of the job
    */
@@ -107,16 +107,25 @@ export const ActivityNotificationJobResponseDtoType$inboundSchema:
   );
 
 /** @internal */
-export const Payload$inboundSchema: z.ZodType<Payload, z.ZodTypeDef, unknown> =
-  z.object({});
+export const ActivityNotificationJobResponseDtoPayload$inboundSchema: z.ZodType<
+  ActivityNotificationJobResponseDtoPayload,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
 
-export function payloadFromJSON(
+export function activityNotificationJobResponseDtoPayloadFromJSON(
   jsonString: string,
-): SafeParseResult<Payload, SDKValidationError> {
+): SafeParseResult<
+  ActivityNotificationJobResponseDtoPayload,
+  SDKValidationError
+> {
   return safeParse(
     jsonString,
-    (x) => Payload$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Payload' from JSON`,
+    (x) =>
+      ActivityNotificationJobResponseDtoPayload$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ActivityNotificationJobResponseDtoPayload' from JSON`,
   );
 }
 
@@ -134,7 +143,8 @@ export const ActivityNotificationJobResponseDto$inboundSchema: z.ZodType<
   ),
   step: ActivityNotificationStepResponseDto$inboundSchema,
   overrides: z.record(z.any()).optional(),
-  payload: z.lazy(() => Payload$inboundSchema).optional(),
+  payload: z.lazy(() => ActivityNotificationJobResponseDtoPayload$inboundSchema)
+    .optional(),
   providerId: ProvidersIdEnum$inboundSchema,
   status: z.string(),
   updatedAt: z.string().optional(),

package/src/models/components/createchannelconnectionrequestdto.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
 import {
   AuthDto,
   AuthDto$Outbound,
@@ -29,6 +30,18 @@ export type CreateChannelConnectionRequestDtoContext =
   | CreateChannelConnectionRequestDtoContext2
   | string;
 
+/**
+ * Connection mode that determines how the channel connection is scoped. Use "subscriber" (default) to associate the connection with a specific subscriber. Use "shared" to associate the connection with a context instead of a subscriber — subscriberId will not be stored on the connection.
+ */
+export const ConnectionMode = {
+  Subscriber: "subscriber",
+  Shared: "shared",
+} as const;
+/**
+ * Connection mode that determines how the channel connection is scoped. Use "subscriber" (default) to associate the connection with a specific subscriber. Use "shared" to associate the connection with a context instead of a subscriber — subscriberId will not be stored on the connection.
+ */
+export type ConnectionMode = ClosedEnum<typeof ConnectionMode>;
+
 export type CreateChannelConnectionRequestDto = {
   /**
    * The unique identifier for the channel connection. If not provided, one will be generated automatically.
@@ -41,6 +54,10 @@ export type CreateChannelConnectionRequestDto = {
   context?:
     | { [k: string]: CreateChannelConnectionRequestDtoContext2 | string }
     | undefined;
+  /**
+   * Connection mode that determines how the channel connection is scoped. Use "subscriber" (default) to associate the connection with a specific subscriber. Use "shared" to associate the connection with a context instead of a subscriber — subscriberId will not be stored on the connection.
+   */
+  connectionMode?: ConnectionMode | undefined;
   /**
    * The identifier of the integration to use for this channel connection.
    */
@@ -103,6 +120,11 @@ export function createChannelConnectionRequestDtoContextToJSON(
   );
 }
 
+/** @internal */
+export const ConnectionMode$outboundSchema: z.ZodNativeEnum<
+  typeof ConnectionMode
+> = z.nativeEnum(ConnectionMode);
+
 /** @internal */
 export type CreateChannelConnectionRequestDto$Outbound = {
   identifier?: string | undefined;
@@ -110,6 +132,7 @@ export type CreateChannelConnectionRequestDto$Outbound = {
   context?: {
     [k: string]: CreateChannelConnectionRequestDtoContext2$Outbound | string;
   } | undefined;
+  connectionMode?: string | undefined;
   integrationIdentifier: string;
   workspace: WorkspaceDto$Outbound;
   auth: AuthDto$Outbound;
@@ -129,6 +152,7 @@ export const CreateChannelConnectionRequestDto$outboundSchema: z.ZodType<
       z.string(),
     ]),
   ).optional(),
+  connectionMode: ConnectionMode$outboundSchema.optional(),
   integrationIdentifier: z.string(),
   workspace: WorkspaceDto$outboundSchema,
   auth: AuthDto$outboundSchema,

package/src/models/components/createdomainconnectapplyurldto.ts

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type CreateDomainConnectApplyUrlDto = {
+  /**
+   * Dashboard URL to return to after the DNS provider consent flow completes.
+   */
+  redirectUri?: string | undefined;
+};
+
+/** @internal */
+export type CreateDomainConnectApplyUrlDto$Outbound = {
+  redirectUri?: string | undefined;
+};
+
+/** @internal */
+export const CreateDomainConnectApplyUrlDto$outboundSchema: z.ZodType<
+  CreateDomainConnectApplyUrlDto$Outbound,
+  z.ZodTypeDef,
+  CreateDomainConnectApplyUrlDto
+> = z.object({
+  redirectUri: z.string().optional(),
+});
+
+export function createDomainConnectApplyUrlDtoToJSON(
+  createDomainConnectApplyUrlDto: CreateDomainConnectApplyUrlDto,
+): string {
+  return JSON.stringify(
+    CreateDomainConnectApplyUrlDto$outboundSchema.parse(
+      createDomainConnectApplyUrlDto,
+    ),
+  );
+}

package/src/models/components/createdomaindto.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type CreateDomainDto = {
+  /**
+   * The domain name (e.g. "recent.dev")
+   */
+  name: string;
+  /**
+   * Optional string key-value metadata (max 10 keys, 500 characters total for keys+values).
+   */
+  data?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export type CreateDomainDto$Outbound = {
+  name: string;
+  data?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const CreateDomainDto$outboundSchema: z.ZodType<
+  CreateDomainDto$Outbound,
+  z.ZodTypeDef,
+  CreateDomainDto
+> = z.object({
+  name: z.string(),
+  data: z.record(z.string()).optional(),
+});
+
+export function createDomainDtoToJSON(
+  createDomainDto: CreateDomainDto,
+): string {
+  return JSON.stringify(CreateDomainDto$outboundSchema.parse(createDomainDto));
+}

package/src/models/components/credentialsdto.ts

@@ -57,6 +57,8 @@ export type CredentialsDto = {
   senderId?: string | undefined;
   tenantId?: string | undefined;
   appIOBaseUrl?: string | undefined;
+  signingSecret?: string | undefined;
+  outboundIntegrationId?: string | undefined;
 };
 
 /** @internal */
@@ -140,6 +142,8 @@ export const CredentialsDto$inboundSchema: z.ZodType<
   senderId: z.string().optional(),
   tenantId: z.string().optional(),
   AppIOBaseUrl: z.string().optional(),
+  signingSecret: z.string().optional(),
+  outboundIntegrationId: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     "AppIOBaseUrl": "appIOBaseUrl",
@@ -193,6 +197,8 @@ export type CredentialsDto$Outbound = {
   senderId?: string | undefined;
   tenantId?: string | undefined;
   AppIOBaseUrl?: string | undefined;
+  signingSecret?: string | undefined;
+  outboundIntegrationId?: string | undefined;
 };
 
 /** @internal */
@@ -247,6 +253,8 @@ export const CredentialsDto$outboundSchema: z.ZodType<
   senderId: z.string().optional(),
   tenantId: z.string().optional(),
   appIOBaseUrl: z.string().optional(),
+  signingSecret: z.string().optional(),
+  outboundIntegrationId: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     appIOBaseUrl: "AppIOBaseUrl",

package/src/models/components/diagnosedomainresponsedto.ts

@@ -0,0 +1,51 @@
+/*
+ * 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 {
+  DomainDiagnosticCheckDto,
+  DomainDiagnosticCheckDto$inboundSchema,
+} from "./domaindiagnosticcheckdto.js";
+import {
+  DomainDiagnosticIssueDto,
+  DomainDiagnosticIssueDto$inboundSchema,
+} from "./domaindiagnosticissuedto.js";
+
+export type DiagnoseDomainResponseDto = {
+  /**
+   * True when there are no error-severity issues
+   */
+  ok: boolean;
+  /**
+   * ISO timestamp when the diagnostic run finished
+   */
+  runAt: string;
+  checks: Array<DomainDiagnosticCheckDto>;
+  issues: Array<DomainDiagnosticIssueDto>;
+};
+
+/** @internal */
+export const DiagnoseDomainResponseDto$inboundSchema: z.ZodType<
+  DiagnoseDomainResponseDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ok: z.boolean(),
+  runAt: z.string(),
+  checks: z.array(DomainDiagnosticCheckDto$inboundSchema),
+  issues: z.array(DomainDiagnosticIssueDto$inboundSchema),
+});
+
+export function diagnoseDomainResponseDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<DiagnoseDomainResponseDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DiagnoseDomainResponseDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DiagnoseDomainResponseDto' from JSON`,
+  );
+}

package/src/models/components/domainconnectapplyurlresponsedto.ts

@@ -0,0 +1,35 @@
+/*
+ * 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 DomainConnectApplyUrlResponseDto = {
+  applyUrl: string;
+  providerName: string;
+  redirectUri: string;
+};
+
+/** @internal */
+export const DomainConnectApplyUrlResponseDto$inboundSchema: z.ZodType<
+  DomainConnectApplyUrlResponseDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  applyUrl: z.string(),
+  providerName: z.string(),
+  redirectUri: z.string(),
+});
+
+export function domainConnectApplyUrlResponseDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<DomainConnectApplyUrlResponseDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DomainConnectApplyUrlResponseDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainConnectApplyUrlResponseDto' from JSON`,
+  );
+}

package/src/models/components/domainconnectstatusresponsedto.ts

@@ -0,0 +1,61 @@
+/*
+ * 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 {
+  ExpectedDnsRecordDto,
+  ExpectedDnsRecordDto$inboundSchema,
+} from "./expecteddnsrecorddto.js";
+
+export const ReasonCode = {
+  Disabled: "disabled",
+  DiscoveryNotConfigured: "discovery_not_configured",
+  UnsupportedProvider: "unsupported_provider",
+  IncompleteConfiguration: "incomplete_configuration",
+  ProviderSettingsUnavailable: "provider_settings_unavailable",
+  UntrustedProviderFlow: "untrusted_provider_flow",
+  TemplateNotOnboarded: "template_not_onboarded",
+} as const;
+export type ReasonCode = ClosedEnum<typeof ReasonCode>;
+
+export type DomainConnectStatusResponseDto = {
+  available: boolean;
+  providerName?: string | undefined;
+  providerId?: string | undefined;
+  reason?: string | undefined;
+  reasonCode?: ReasonCode | undefined;
+  manualRecords: Array<ExpectedDnsRecordDto>;
+};
+
+/** @internal */
+export const ReasonCode$inboundSchema: z.ZodNativeEnum<typeof ReasonCode> = z
+  .nativeEnum(ReasonCode);
+
+/** @internal */
+export const DomainConnectStatusResponseDto$inboundSchema: z.ZodType<
+  DomainConnectStatusResponseDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  available: z.boolean(),
+  providerName: z.string().optional(),
+  providerId: z.string().optional(),
+  reason: z.string().optional(),
+  reasonCode: ReasonCode$inboundSchema.optional(),
+  manualRecords: z.array(ExpectedDnsRecordDto$inboundSchema),
+});
+
+export function domainConnectStatusResponseDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<DomainConnectStatusResponseDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DomainConnectStatusResponseDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainConnectStatusResponseDto' from JSON`,
+  );
+}

package/src/models/components/domaindiagnosticcheckdto.ts

@@ -0,0 +1,67 @@
+/*
+ * 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";
+
+export const Code = {
+  MxMissing: "mx_missing",
+  MxWrongTarget: "mx_wrong_target",
+  MxLowPriority: "mx_low_priority",
+  ApexCnameCollision: "apex_cname_collision",
+  DnsblListed: "dnsbl_listed",
+} as const;
+export type Code = ClosedEnum<typeof Code>;
+
+export const DomainDiagnosticCheckDtoStatus = {
+  Pass: "pass",
+  Fail: "fail",
+  Skipped: "skipped",
+} as const;
+export type DomainDiagnosticCheckDtoStatus = ClosedEnum<
+  typeof DomainDiagnosticCheckDtoStatus
+>;
+
+export type DomainDiagnosticCheckDto = {
+  code: Code;
+  status: DomainDiagnosticCheckDtoStatus;
+  /**
+   * Round-trip time for this check in milliseconds
+   */
+  latencyMs: number;
+};
+
+/** @internal */
+export const Code$inboundSchema: z.ZodNativeEnum<typeof Code> = z.nativeEnum(
+  Code,
+);
+
+/** @internal */
+export const DomainDiagnosticCheckDtoStatus$inboundSchema: z.ZodNativeEnum<
+  typeof DomainDiagnosticCheckDtoStatus
+> = z.nativeEnum(DomainDiagnosticCheckDtoStatus);
+
+/** @internal */
+export const DomainDiagnosticCheckDto$inboundSchema: z.ZodType<
+  DomainDiagnosticCheckDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: Code$inboundSchema,
+  status: DomainDiagnosticCheckDtoStatus$inboundSchema,
+  latencyMs: z.number(),
+});
+
+export function domainDiagnosticCheckDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<DomainDiagnosticCheckDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DomainDiagnosticCheckDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainDiagnosticCheckDto' from JSON`,
+  );
+}

package/src/models/components/domaindiagnosticissuedto.ts

@@ -0,0 +1,67 @@
+/*
+ * 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";
+
+export const DomainDiagnosticIssueDtoCode = {
+  MxMissing: "mx_missing",
+  MxWrongTarget: "mx_wrong_target",
+  MxLowPriority: "mx_low_priority",
+  ApexCnameCollision: "apex_cname_collision",
+  DnsblListed: "dnsbl_listed",
+} as const;
+export type DomainDiagnosticIssueDtoCode = ClosedEnum<
+  typeof DomainDiagnosticIssueDtoCode
+>;
+
+export const Severity = {
+  Warn: "warn",
+  Error: "error",
+} as const;
+export type Severity = ClosedEnum<typeof Severity>;
+
+export type DomainDiagnosticIssueDto = {
+  code: DomainDiagnosticIssueDtoCode;
+  severity: Severity;
+  message: string;
+  /**
+   * Plain-language remediation guidance
+   */
+  fix: string;
+};
+
+/** @internal */
+export const DomainDiagnosticIssueDtoCode$inboundSchema: z.ZodNativeEnum<
+  typeof DomainDiagnosticIssueDtoCode
+> = z.nativeEnum(DomainDiagnosticIssueDtoCode);
+
+/** @internal */
+export const Severity$inboundSchema: z.ZodNativeEnum<typeof Severity> = z
+  .nativeEnum(Severity);
+
+/** @internal */
+export const DomainDiagnosticIssueDto$inboundSchema: z.ZodType<
+  DomainDiagnosticIssueDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: DomainDiagnosticIssueDtoCode$inboundSchema,
+  severity: Severity$inboundSchema,
+  message: z.string(),
+  fix: z.string(),
+});
+
+export function domainDiagnosticIssueDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<DomainDiagnosticIssueDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DomainDiagnosticIssueDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainDiagnosticIssueDto' from JSON`,
+  );
+}

package/src/models/components/domainresponsedto.ts

@@ -0,0 +1,79 @@
+/*
+ * 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 { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ExpectedDnsRecordDto,
+  ExpectedDnsRecordDto$inboundSchema,
+} from "./expecteddnsrecorddto.js";
+
+export const DomainResponseDtoStatus = {
+  Pending: "pending",
+  Verified: "verified",
+} as const;
+export type DomainResponseDtoStatus = ClosedEnum<
+  typeof DomainResponseDtoStatus
+>;
+
+export type DomainResponseDto = {
+  id: string;
+  name: string;
+  status: DomainResponseDtoStatus;
+  mxRecordConfigured: boolean;
+  dnsProvider?: string | undefined;
+  environmentId: string;
+  organizationId: string;
+  createdAt: string;
+  updatedAt: string;
+  expectedDnsRecords?: Array<ExpectedDnsRecordDto> | undefined;
+  /**
+   * String key-value metadata (max 10 keys, 500 characters total when set via API).
+   */
+  data?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const DomainResponseDtoStatus$inboundSchema: z.ZodNativeEnum<
+  typeof DomainResponseDtoStatus
+> = z.nativeEnum(DomainResponseDtoStatus);
+
+/** @internal */
+export const DomainResponseDto$inboundSchema: z.ZodType<
+  DomainResponseDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  name: z.string(),
+  status: DomainResponseDtoStatus$inboundSchema,
+  mxRecordConfigured: z.boolean(),
+  dnsProvider: z.string().optional(),
+  _environmentId: z.string(),
+  _organizationId: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  expectedDnsRecords: z.array(ExpectedDnsRecordDto$inboundSchema).optional(),
+  data: z.record(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "_environmentId": "environmentId",
+    "_organizationId": "organizationId",
+  });
+});
+
+export function domainResponseDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<DomainResponseDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DomainResponseDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainResponseDto' from JSON`,
+  );
+}