@novu/api 3.15.0 → 3.15.1-rc.1

package/src/models/components/updatedomainroutedto.ts

@@ -0,0 +1,57 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const UpdateDomainRouteDtoType = {
+  Agent: "agent",
+  Webhook: "webhook",
+} as const;
+export type UpdateDomainRouteDtoType = ClosedEnum<
+  typeof UpdateDomainRouteDtoType
+>;
+
+export type UpdateDomainRouteDto = {
+  /**
+   * Agent identifier; required when type is agent, ignored when type is webhook.
+   */
+  agentId?: string | undefined;
+  type?: UpdateDomainRouteDtoType | undefined;
+  /**
+   * Replaces route metadata when provided (max 10 keys, 500 characters total for keys+values).
+   */
+  data?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const UpdateDomainRouteDtoType$outboundSchema: z.ZodNativeEnum<
+  typeof UpdateDomainRouteDtoType
+> = z.nativeEnum(UpdateDomainRouteDtoType);
+
+/** @internal */
+export type UpdateDomainRouteDto$Outbound = {
+  agentId?: string | undefined;
+  type?: string | undefined;
+  data?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const UpdateDomainRouteDto$outboundSchema: z.ZodType<
+  UpdateDomainRouteDto$Outbound,
+  z.ZodTypeDef,
+  UpdateDomainRouteDto
+> = z.object({
+  agentId: z.string().optional(),
+  type: UpdateDomainRouteDtoType$outboundSchema.optional(),
+  data: z.record(z.string()).optional(),
+});
+
+export function updateDomainRouteDtoToJSON(
+  updateDomainRouteDto: UpdateDomainRouteDto,
+): string {
+  return JSON.stringify(
+    UpdateDomainRouteDto$outboundSchema.parse(updateDomainRouteDto),
+  );
+}

package/src/models/operations/domainscontrollercreatedomain.ts

@@ -0,0 +1,80 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DomainsControllerCreateDomainRequest = {
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+  createDomainDto: components.CreateDomainDto;
+};
+
+export type DomainsControllerCreateDomainResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.DomainResponseDto;
+};
+
+/** @internal */
+export type DomainsControllerCreateDomainRequest$Outbound = {
+  "idempotency-key"?: string | undefined;
+  CreateDomainDto: components.CreateDomainDto$Outbound;
+};
+
+/** @internal */
+export const DomainsControllerCreateDomainRequest$outboundSchema: z.ZodType<
+  DomainsControllerCreateDomainRequest$Outbound,
+  z.ZodTypeDef,
+  DomainsControllerCreateDomainRequest
+> = z.object({
+  idempotencyKey: z.string().optional(),
+  createDomainDto: components.CreateDomainDto$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    idempotencyKey: "idempotency-key",
+    createDomainDto: "CreateDomainDto",
+  });
+});
+
+export function domainsControllerCreateDomainRequestToJSON(
+  domainsControllerCreateDomainRequest: DomainsControllerCreateDomainRequest,
+): string {
+  return JSON.stringify(
+    DomainsControllerCreateDomainRequest$outboundSchema.parse(
+      domainsControllerCreateDomainRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DomainsControllerCreateDomainResponse$inboundSchema: z.ZodType<
+  DomainsControllerCreateDomainResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Headers: z.record(z.array(z.string())).default({}),
+  Result: components.DomainResponseDto$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Headers": "headers",
+    "Result": "result",
+  });
+});
+
+export function domainsControllerCreateDomainResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DomainsControllerCreateDomainResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DomainsControllerCreateDomainResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainsControllerCreateDomainResponse' from JSON`,
+  );
+}

package/src/models/operations/domainscontrollercreatedomainroute.ts

@@ -0,0 +1,88 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DomainsControllerCreateDomainRouteRequest = {
+  domain: string;
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+  domainRouteDto: components.DomainRouteDto;
+};
+
+export type DomainsControllerCreateDomainRouteResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.DomainRouteResponseDto;
+};
+
+/** @internal */
+export type DomainsControllerCreateDomainRouteRequest$Outbound = {
+  domain: string;
+  "idempotency-key"?: string | undefined;
+  DomainRouteDto: components.DomainRouteDto$Outbound;
+};
+
+/** @internal */
+export const DomainsControllerCreateDomainRouteRequest$outboundSchema:
+  z.ZodType<
+    DomainsControllerCreateDomainRouteRequest$Outbound,
+    z.ZodTypeDef,
+    DomainsControllerCreateDomainRouteRequest
+  > = z.object({
+    domain: z.string(),
+    idempotencyKey: z.string().optional(),
+    domainRouteDto: components.DomainRouteDto$outboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "idempotency-key",
+      domainRouteDto: "DomainRouteDto",
+    });
+  });
+
+export function domainsControllerCreateDomainRouteRequestToJSON(
+  domainsControllerCreateDomainRouteRequest:
+    DomainsControllerCreateDomainRouteRequest,
+): string {
+  return JSON.stringify(
+    DomainsControllerCreateDomainRouteRequest$outboundSchema.parse(
+      domainsControllerCreateDomainRouteRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DomainsControllerCreateDomainRouteResponse$inboundSchema:
+  z.ZodType<DomainsControllerCreateDomainRouteResponse, z.ZodTypeDef, unknown> =
+    z.object({
+      Headers: z.record(z.array(z.string())).default({}),
+      Result: components.DomainRouteResponseDto$inboundSchema,
+    }).transform((v) => {
+      return remap$(v, {
+        "Headers": "headers",
+        "Result": "result",
+      });
+    });
+
+export function domainsControllerCreateDomainRouteResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DomainsControllerCreateDomainRouteResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DomainsControllerCreateDomainRouteResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DomainsControllerCreateDomainRouteResponse' from JSON`,
+  );
+}

package/src/models/operations/domainscontrollerdeletedomain.ts

@@ -0,0 +1,75 @@
+/*
+ * 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";
+
+export type DomainsControllerDeleteDomainRequest = {
+  domain: string;
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+};
+
+export type DomainsControllerDeleteDomainResponse = {
+  headers: { [k: string]: Array<string> };
+};
+
+/** @internal */
+export type DomainsControllerDeleteDomainRequest$Outbound = {
+  domain: string;
+  "idempotency-key"?: string | undefined;
+};
+
+/** @internal */
+export const DomainsControllerDeleteDomainRequest$outboundSchema: z.ZodType<
+  DomainsControllerDeleteDomainRequest$Outbound,
+  z.ZodTypeDef,
+  DomainsControllerDeleteDomainRequest
+> = z.object({
+  domain: z.string(),
+  idempotencyKey: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    idempotencyKey: "idempotency-key",
+  });
+});
+
+export function domainsControllerDeleteDomainRequestToJSON(
+  domainsControllerDeleteDomainRequest: DomainsControllerDeleteDomainRequest,
+): string {
+  return JSON.stringify(
+    DomainsControllerDeleteDomainRequest$outboundSchema.parse(
+      domainsControllerDeleteDomainRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DomainsControllerDeleteDomainResponse$inboundSchema: z.ZodType<
+  DomainsControllerDeleteDomainResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Headers: z.record(z.array(z.string())).default({}),
+}).transform((v) => {
+  return remap$(v, {
+    "Headers": "headers",
+  });
+});
+
+export function domainsControllerDeleteDomainResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DomainsControllerDeleteDomainResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DomainsControllerDeleteDomainResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainsControllerDeleteDomainResponse' from JSON`,
+  );
+}

package/src/models/operations/domainscontrollerdeletedomainroute.ts

@@ -0,0 +1,83 @@
+/*
+ * 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";
+
+export type DomainsControllerDeleteDomainRouteRequest = {
+  domain: string;
+  address: string;
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+};
+
+export type DomainsControllerDeleteDomainRouteResponse = {
+  headers: { [k: string]: Array<string> };
+};
+
+/** @internal */
+export type DomainsControllerDeleteDomainRouteRequest$Outbound = {
+  domain: string;
+  address: string;
+  "idempotency-key"?: string | undefined;
+};
+
+/** @internal */
+export const DomainsControllerDeleteDomainRouteRequest$outboundSchema:
+  z.ZodType<
+    DomainsControllerDeleteDomainRouteRequest$Outbound,
+    z.ZodTypeDef,
+    DomainsControllerDeleteDomainRouteRequest
+  > = z.object({
+    domain: z.string(),
+    address: z.string(),
+    idempotencyKey: z.string().optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "idempotency-key",
+    });
+  });
+
+export function domainsControllerDeleteDomainRouteRequestToJSON(
+  domainsControllerDeleteDomainRouteRequest:
+    DomainsControllerDeleteDomainRouteRequest,
+): string {
+  return JSON.stringify(
+    DomainsControllerDeleteDomainRouteRequest$outboundSchema.parse(
+      domainsControllerDeleteDomainRouteRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DomainsControllerDeleteDomainRouteResponse$inboundSchema:
+  z.ZodType<DomainsControllerDeleteDomainRouteResponse, z.ZodTypeDef, unknown> =
+    z.object({
+      Headers: z.record(z.array(z.string())).default({}),
+    }).transform((v) => {
+      return remap$(v, {
+        "Headers": "headers",
+      });
+    });
+
+export function domainsControllerDeleteDomainRouteResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DomainsControllerDeleteDomainRouteResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DomainsControllerDeleteDomainRouteResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DomainsControllerDeleteDomainRouteResponse' from JSON`,
+  );
+}

package/src/models/operations/domainscontrollerdiagnosedomain.ts

@@ -0,0 +1,85 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DomainsControllerDiagnoseDomainRequest = {
+  domain: string;
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+};
+
+export type DomainsControllerDiagnoseDomainResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.DiagnoseDomainResponseDto;
+};
+
+/** @internal */
+export type DomainsControllerDiagnoseDomainRequest$Outbound = {
+  domain: string;
+  "idempotency-key"?: string | undefined;
+};
+
+/** @internal */
+export const DomainsControllerDiagnoseDomainRequest$outboundSchema: z.ZodType<
+  DomainsControllerDiagnoseDomainRequest$Outbound,
+  z.ZodTypeDef,
+  DomainsControllerDiagnoseDomainRequest
+> = z.object({
+  domain: z.string(),
+  idempotencyKey: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    idempotencyKey: "idempotency-key",
+  });
+});
+
+export function domainsControllerDiagnoseDomainRequestToJSON(
+  domainsControllerDiagnoseDomainRequest:
+    DomainsControllerDiagnoseDomainRequest,
+): string {
+  return JSON.stringify(
+    DomainsControllerDiagnoseDomainRequest$outboundSchema.parse(
+      domainsControllerDiagnoseDomainRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DomainsControllerDiagnoseDomainResponse$inboundSchema: z.ZodType<
+  DomainsControllerDiagnoseDomainResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Headers: z.record(z.array(z.string())).default({}),
+  Result: components.DiagnoseDomainResponseDto$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Headers": "headers",
+    "Result": "result",
+  });
+});
+
+export function domainsControllerDiagnoseDomainResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DomainsControllerDiagnoseDomainResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DomainsControllerDiagnoseDomainResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DomainsControllerDiagnoseDomainResponse' from JSON`,
+  );
+}

package/src/models/operations/domainscontrollergetdomain.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 { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DomainsControllerGetDomainRequest = {
+  domain: string;
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+};
+
+export type DomainsControllerGetDomainResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.DomainResponseDto;
+};
+
+/** @internal */
+export type DomainsControllerGetDomainRequest$Outbound = {
+  domain: string;
+  "idempotency-key"?: string | undefined;
+};
+
+/** @internal */
+export const DomainsControllerGetDomainRequest$outboundSchema: z.ZodType<
+  DomainsControllerGetDomainRequest$Outbound,
+  z.ZodTypeDef,
+  DomainsControllerGetDomainRequest
+> = z.object({
+  domain: z.string(),
+  idempotencyKey: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    idempotencyKey: "idempotency-key",
+  });
+});
+
+export function domainsControllerGetDomainRequestToJSON(
+  domainsControllerGetDomainRequest: DomainsControllerGetDomainRequest,
+): string {
+  return JSON.stringify(
+    DomainsControllerGetDomainRequest$outboundSchema.parse(
+      domainsControllerGetDomainRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DomainsControllerGetDomainResponse$inboundSchema: z.ZodType<
+  DomainsControllerGetDomainResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Headers: z.record(z.array(z.string())).default({}),
+  Result: components.DomainResponseDto$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Headers": "headers",
+    "Result": "result",
+  });
+});
+
+export function domainsControllerGetDomainResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DomainsControllerGetDomainResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DomainsControllerGetDomainResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainsControllerGetDomainResponse' from JSON`,
+  );
+}

package/src/models/operations/domainscontrollergetdomainautoconfigure.ts

@@ -0,0 +1,87 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DomainsControllerGetDomainAutoConfigureRequest = {
+  domain: string;
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+};
+
+export type DomainsControllerGetDomainAutoConfigureResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.DomainConnectStatusResponseDto;
+};
+
+/** @internal */
+export type DomainsControllerGetDomainAutoConfigureRequest$Outbound = {
+  domain: string;
+  "idempotency-key"?: string | undefined;
+};
+
+/** @internal */
+export const DomainsControllerGetDomainAutoConfigureRequest$outboundSchema:
+  z.ZodType<
+    DomainsControllerGetDomainAutoConfigureRequest$Outbound,
+    z.ZodTypeDef,
+    DomainsControllerGetDomainAutoConfigureRequest
+  > = z.object({
+    domain: z.string(),
+    idempotencyKey: z.string().optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "idempotency-key",
+    });
+  });
+
+export function domainsControllerGetDomainAutoConfigureRequestToJSON(
+  domainsControllerGetDomainAutoConfigureRequest:
+    DomainsControllerGetDomainAutoConfigureRequest,
+): string {
+  return JSON.stringify(
+    DomainsControllerGetDomainAutoConfigureRequest$outboundSchema.parse(
+      domainsControllerGetDomainAutoConfigureRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DomainsControllerGetDomainAutoConfigureResponse$inboundSchema:
+  z.ZodType<
+    DomainsControllerGetDomainAutoConfigureResponse,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    Headers: z.record(z.array(z.string())).default({}),
+    Result: components.DomainConnectStatusResponseDto$inboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      "Headers": "headers",
+      "Result": "result",
+    });
+  });
+
+export function domainsControllerGetDomainAutoConfigureResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DomainsControllerGetDomainAutoConfigureResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DomainsControllerGetDomainAutoConfigureResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DomainsControllerGetDomainAutoConfigureResponse' from JSON`,
+  );
+}