@novu/api 3.15.0 → 3.15.1-rc.1

package/src/models/operations/domainscontrollergetdomainroute.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 DomainsControllerGetDomainRouteRequest = {
+  domain: string;
+  address: string;
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+};
+
+export type DomainsControllerGetDomainRouteResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.DomainRouteResponseDto;
+};
+
+/** @internal */
+export type DomainsControllerGetDomainRouteRequest$Outbound = {
+  domain: string;
+  address: string;
+  "idempotency-key"?: string | undefined;
+};
+
+/** @internal */
+export const DomainsControllerGetDomainRouteRequest$outboundSchema: z.ZodType<
+  DomainsControllerGetDomainRouteRequest$Outbound,
+  z.ZodTypeDef,
+  DomainsControllerGetDomainRouteRequest
+> = z.object({
+  domain: z.string(),
+  address: z.string(),
+  idempotencyKey: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    idempotencyKey: "idempotency-key",
+  });
+});
+
+export function domainsControllerGetDomainRouteRequestToJSON(
+  domainsControllerGetDomainRouteRequest:
+    DomainsControllerGetDomainRouteRequest,
+): string {
+  return JSON.stringify(
+    DomainsControllerGetDomainRouteRequest$outboundSchema.parse(
+      domainsControllerGetDomainRouteRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DomainsControllerGetDomainRouteResponse$inboundSchema: z.ZodType<
+  DomainsControllerGetDomainRouteResponse,
+  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 domainsControllerGetDomainRouteResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DomainsControllerGetDomainRouteResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DomainsControllerGetDomainRouteResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DomainsControllerGetDomainRouteResponse' from JSON`,
+  );
+}

package/src/models/operations/domainscontrollerlistdomainroutes.ts

@@ -0,0 +1,151 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Direction of sorting
+ */
+export const DomainsControllerListDomainRoutesQueryParamOrderDirection = {
+  Asc: "ASC",
+  Desc: "DESC",
+} as const;
+/**
+ * Direction of sorting
+ */
+export type DomainsControllerListDomainRoutesQueryParamOrderDirection =
+  ClosedEnum<typeof DomainsControllerListDomainRoutesQueryParamOrderDirection>;
+
+export type DomainsControllerListDomainRoutesRequest = {
+  domain: string;
+  /**
+   * Cursor for pagination indicating the starting point after which to fetch results.
+   */
+  after?: string | undefined;
+  /**
+   * Cursor for pagination indicating the ending point before which to fetch results.
+   */
+  before?: string | undefined;
+  /**
+   * Limit the number of items to return
+   */
+  limit?: number | undefined;
+  /**
+   * Direction of sorting
+   */
+  orderDirection?:
+    | DomainsControllerListDomainRoutesQueryParamOrderDirection
+    | undefined;
+  /**
+   * Field to order by
+   */
+  orderBy?: string | undefined;
+  /**
+   * Include cursor item in response
+   */
+  includeCursor?: boolean | undefined;
+  /**
+   * Agent identifier to filter routes by.
+   */
+  agentId?: string | undefined;
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+};
+
+export type DomainsControllerListDomainRoutesResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.ListDomainRoutesResponseDto;
+};
+
+/** @internal */
+export const DomainsControllerListDomainRoutesQueryParamOrderDirection$outboundSchema:
+  z.ZodNativeEnum<
+    typeof DomainsControllerListDomainRoutesQueryParamOrderDirection
+  > = z.nativeEnum(DomainsControllerListDomainRoutesQueryParamOrderDirection);
+
+/** @internal */
+export type DomainsControllerListDomainRoutesRequest$Outbound = {
+  domain: string;
+  after?: string | undefined;
+  before?: string | undefined;
+  limit?: number | undefined;
+  orderDirection?: string | undefined;
+  orderBy?: string | undefined;
+  includeCursor?: boolean | undefined;
+  agentId?: string | undefined;
+  "idempotency-key"?: string | undefined;
+};
+
+/** @internal */
+export const DomainsControllerListDomainRoutesRequest$outboundSchema: z.ZodType<
+  DomainsControllerListDomainRoutesRequest$Outbound,
+  z.ZodTypeDef,
+  DomainsControllerListDomainRoutesRequest
+> = z.object({
+  domain: z.string(),
+  after: z.string().optional(),
+  before: z.string().optional(),
+  limit: z.number().optional(),
+  orderDirection:
+    DomainsControllerListDomainRoutesQueryParamOrderDirection$outboundSchema
+      .optional(),
+  orderBy: z.string().optional(),
+  includeCursor: z.boolean().optional(),
+  agentId: z.string().optional(),
+  idempotencyKey: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    idempotencyKey: "idempotency-key",
+  });
+});
+
+export function domainsControllerListDomainRoutesRequestToJSON(
+  domainsControllerListDomainRoutesRequest:
+    DomainsControllerListDomainRoutesRequest,
+): string {
+  return JSON.stringify(
+    DomainsControllerListDomainRoutesRequest$outboundSchema.parse(
+      domainsControllerListDomainRoutesRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DomainsControllerListDomainRoutesResponse$inboundSchema: z.ZodType<
+  DomainsControllerListDomainRoutesResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Headers: z.record(z.array(z.string())).default({}),
+  Result: components.ListDomainRoutesResponseDto$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Headers": "headers",
+    "Result": "result",
+  });
+});
+
+export function domainsControllerListDomainRoutesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DomainsControllerListDomainRoutesResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DomainsControllerListDomainRoutesResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DomainsControllerListDomainRoutesResponse' from JSON`,
+  );
+}

package/src/models/operations/domainscontrollerlistdomains.ts

@@ -0,0 +1,142 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Direction of sorting
+ */
+export const DomainsControllerListDomainsQueryParamOrderDirection = {
+  Asc: "ASC",
+  Desc: "DESC",
+} as const;
+/**
+ * Direction of sorting
+ */
+export type DomainsControllerListDomainsQueryParamOrderDirection = ClosedEnum<
+  typeof DomainsControllerListDomainsQueryParamOrderDirection
+>;
+
+export type DomainsControllerListDomainsRequest = {
+  /**
+   * Cursor for pagination indicating the starting point after which to fetch results.
+   */
+  after?: string | undefined;
+  /**
+   * Cursor for pagination indicating the ending point before which to fetch results.
+   */
+  before?: string | undefined;
+  /**
+   * Limit the number of items to return
+   */
+  limit?: number | undefined;
+  /**
+   * Direction of sorting
+   */
+  orderDirection?:
+    | DomainsControllerListDomainsQueryParamOrderDirection
+    | undefined;
+  /**
+   * Field to order by
+   */
+  orderBy?: string | undefined;
+  /**
+   * Include cursor item in response
+   */
+  includeCursor?: boolean | undefined;
+  /**
+   * Domain name to filter results by.
+   */
+  name?: string | undefined;
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+};
+
+export type DomainsControllerListDomainsResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.ListDomainsResponseDto;
+};
+
+/** @internal */
+export const DomainsControllerListDomainsQueryParamOrderDirection$outboundSchema:
+  z.ZodNativeEnum<typeof DomainsControllerListDomainsQueryParamOrderDirection> =
+    z.nativeEnum(DomainsControllerListDomainsQueryParamOrderDirection);
+
+/** @internal */
+export type DomainsControllerListDomainsRequest$Outbound = {
+  after?: string | undefined;
+  before?: string | undefined;
+  limit?: number | undefined;
+  orderDirection?: string | undefined;
+  orderBy?: string | undefined;
+  includeCursor?: boolean | undefined;
+  name?: string | undefined;
+  "idempotency-key"?: string | undefined;
+};
+
+/** @internal */
+export const DomainsControllerListDomainsRequest$outboundSchema: z.ZodType<
+  DomainsControllerListDomainsRequest$Outbound,
+  z.ZodTypeDef,
+  DomainsControllerListDomainsRequest
+> = z.object({
+  after: z.string().optional(),
+  before: z.string().optional(),
+  limit: z.number().optional(),
+  orderDirection:
+    DomainsControllerListDomainsQueryParamOrderDirection$outboundSchema
+      .optional(),
+  orderBy: z.string().optional(),
+  includeCursor: z.boolean().optional(),
+  name: z.string().optional(),
+  idempotencyKey: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    idempotencyKey: "idempotency-key",
+  });
+});
+
+export function domainsControllerListDomainsRequestToJSON(
+  domainsControllerListDomainsRequest: DomainsControllerListDomainsRequest,
+): string {
+  return JSON.stringify(
+    DomainsControllerListDomainsRequest$outboundSchema.parse(
+      domainsControllerListDomainsRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DomainsControllerListDomainsResponse$inboundSchema: z.ZodType<
+  DomainsControllerListDomainsResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Headers: z.record(z.array(z.string())).default({}),
+  Result: components.ListDomainsResponseDto$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Headers": "headers",
+    "Result": "result",
+  });
+});
+
+export function domainsControllerListDomainsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DomainsControllerListDomainsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DomainsControllerListDomainsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainsControllerListDomainsResponse' from JSON`,
+  );
+}

package/src/models/operations/domainscontrollerstartdomainautoconfigure.ts

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

package/src/models/operations/domainscontrollertestdomainroute.ts

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

package/src/models/operations/domainscontrollerupdatedomain.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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DomainsControllerUpdateDomainRequest = {
+  domain: string;
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+  updateDomainDto: components.UpdateDomainDto;
+};
+
+export type DomainsControllerUpdateDomainResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.DomainResponseDto;
+};
+
+/** @internal */
+export type DomainsControllerUpdateDomainRequest$Outbound = {
+  domain: string;
+  "idempotency-key"?: string | undefined;
+  UpdateDomainDto: components.UpdateDomainDto$Outbound;
+};
+
+/** @internal */
+export const DomainsControllerUpdateDomainRequest$outboundSchema: z.ZodType<
+  DomainsControllerUpdateDomainRequest$Outbound,
+  z.ZodTypeDef,
+  DomainsControllerUpdateDomainRequest
+> = z.object({
+  domain: z.string(),
+  idempotencyKey: z.string().optional(),
+  updateDomainDto: components.UpdateDomainDto$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    idempotencyKey: "idempotency-key",
+    updateDomainDto: "UpdateDomainDto",
+  });
+});
+
+export function domainsControllerUpdateDomainRequestToJSON(
+  domainsControllerUpdateDomainRequest: DomainsControllerUpdateDomainRequest,
+): string {
+  return JSON.stringify(
+    DomainsControllerUpdateDomainRequest$outboundSchema.parse(
+      domainsControllerUpdateDomainRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DomainsControllerUpdateDomainResponse$inboundSchema: z.ZodType<
+  DomainsControllerUpdateDomainResponse,
+  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 domainsControllerUpdateDomainResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DomainsControllerUpdateDomainResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DomainsControllerUpdateDomainResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainsControllerUpdateDomainResponse' from JSON`,
+  );
+}