@novu/api 3.17.1 → 3.18.1

package/src/funcs/integrationsGenerateConnectOAuthUrl.ts

@@ -31,7 +31,7 @@ import { Result } from "../types/fp.js";
  * Generate OAuth URL for a workspace/tenant connection
  *
  * @remarks
- * Generate an OAuth URL that creates a workspace or tenant-level channel connection (Slack workspace install or MS Teams admin consent).
+ * Generate an OAuth URL that creates a workspace or tenant-level channel connection (Slack workspace install, MS Teams admin consent, or Webex integration authorization).
  *     The generated URL expires after 5 minutes.
  */
 export function integrationsGenerateConnectOAuthUrl(

package/src/funcs/integrationsGenerateLinkUserOAuthUrl.ts

@@ -31,7 +31,7 @@ import { Result } from "../types/fp.js";
  * Generate OAuth URL to link a subscriber user identity
  *
  * @remarks
- * Generate an OAuth URL that links a specific subscriber to their chat identity (Slack user ID or MS Teams user OID).
+ * Generate an OAuth URL that links a specific subscriber to their chat identity (Slack user ID, MS Teams user OID, or Webex person).
  *     The generated URL expires after 5 minutes.
  */
 export function integrationsGenerateLinkUserOAuthUrl(

package/src/lib/config.ts

@@ -58,8 +58,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 
 export const SDK_METADATA = {
   language: "typescript",
-  openapiDocVersion: "3.17.1",
-  sdkVersion: "3.17.1",
-  genVersion: "2.916.2",
-  userAgent: "speakeasy-sdk/typescript 3.17.1 2.916.2 3.17.1 @novu/api",
+  openapiDocVersion: "3.18.1",
+  sdkVersion: "3.18.1",
+  genVersion: "2.918.3",
+  userAgent: "speakeasy-sdk/typescript 3.18.1 2.918.3 3.18.1 @novu/api",
 } as const;

package/src/lib/http.ts

@@ -45,8 +45,10 @@ export class HTTPClient {
   private requestHooks: BeforeRequestHook[] = [];
   private requestErrorHooks: RequestErrorHook[] = [];
   private responseHooks: ResponseHook[] = [];
+  private options: HTTPClientOptions;
 
-  constructor(private options: HTTPClientOptions = {}) {
+  constructor(options: HTTPClientOptions = {}) {
+    this.options = options;
     this.fetcher = options.fetcher || DEFAULT_FETCHER;
   }
 

package/src/lib/security.ts

@@ -12,17 +12,22 @@ type OAuth2PasswordFlow = {
   tokenURL: string;
 };
 
-export enum SecurityErrorCode {
-  Incomplete = "incomplete",
-  UnrecognisedSecurityType = "unrecognized_security_type",
-}
+export const SecurityErrorCode = {
+  Incomplete: "incomplete",
+  UnrecognisedSecurityType: "unrecognized_security_type",
+} as const;
+export type SecurityErrorCode =
+  (typeof SecurityErrorCode)[keyof typeof SecurityErrorCode];
 
 export class SecurityError extends Error {
+  public code: SecurityErrorCode;
+
   constructor(
-    public code: SecurityErrorCode,
+    code: SecurityErrorCode,
     message: string,
   ) {
     super(message);
+    this.code = code;
     this.name = "SecurityError";
   }
 

package/src/models/components/addagentintegrationrequestdto.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type AddAgentIntegrationRequestDto = {
+  /**
+   * The integration identifier (same as in the integration store), not the internal document _id.
+   */
+  integrationIdentifier?: string | undefined;
+  /**
+   * Provider ID to auto-create a dedicated integration (e.g. novu-agent-email). When set, the server creates the integration if one does not already exist for this agent.
+   */
+  providerId?: string | undefined;
+};
+
+/** @internal */
+export type AddAgentIntegrationRequestDto$Outbound = {
+  integrationIdentifier?: string | undefined;
+  providerId?: string | undefined;
+};
+
+/** @internal */
+export const AddAgentIntegrationRequestDto$outboundSchema: z.ZodType<
+  AddAgentIntegrationRequestDto$Outbound,
+  z.ZodTypeDef,
+  AddAgentIntegrationRequestDto
+> = z.object({
+  integrationIdentifier: z.string().optional(),
+  providerId: z.string().optional(),
+});
+
+export function addAgentIntegrationRequestDtoToJSON(
+  addAgentIntegrationRequestDto: AddAgentIntegrationRequestDto,
+): string {
+  return JSON.stringify(
+    AddAgentIntegrationRequestDto$outboundSchema.parse(
+      addAgentIntegrationRequestDto,
+    ),
+  );
+}

package/src/models/components/addreactionpayloaddto.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type AddReactionPayloadDto = {
+  /**
+   * Platform message id to react to.
+   */
+  messageId: string;
+  /**
+   * Well-known cross-platform emoji name (e.g. `white_check_mark`, `thumbsup`).
+   */
+  emojiName: string;
+};
+
+/** @internal */
+export type AddReactionPayloadDto$Outbound = {
+  messageId: string;
+  emojiName: string;
+};
+
+/** @internal */
+export const AddReactionPayloadDto$outboundSchema: z.ZodType<
+  AddReactionPayloadDto$Outbound,
+  z.ZodTypeDef,
+  AddReactionPayloadDto
+> = z.object({
+  messageId: z.string(),
+  emojiName: z.string(),
+});
+
+export function addReactionPayloadDtoToJSON(
+  addReactionPayloadDto: AddReactionPayloadDto,
+): string {
+  return JSON.stringify(
+    AddReactionPayloadDto$outboundSchema.parse(addReactionPayloadDto),
+  );
+}

package/src/models/components/agentbehaviordto.ts

@@ -0,0 +1,131 @@
+/*
+ * 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";
+
+/**
+ * Cross-platform emoji name for resolved conversations (e.g. "check", "star"). Set to null to disable. Default: "check"
+ */
+export type ReactionOnResolved = {};
+
+/**
+ * Controls whether the agent accepts inbound messages from senders not yet linked to a subscriber, across all channels. "open" on managed agents auto-creates a lightweight subscriber so the agent can reply; on custom-code / self-hosted agents, the turn is forwarded to the bridge with a null subscriber. "restricted" rejects unknown senders with a managed denial reply (any runtime). Unset resolves as "restricted". Managed agent create defaults to "open"; self-hosted create defaults to "restricted".
+ */
+export const SubscriberAccess = {
+  Open: "open",
+  Restricted: "restricted",
+} as const;
+/**
+ * Controls whether the agent accepts inbound messages from senders not yet linked to a subscriber, across all channels. "open" on managed agents auto-creates a lightweight subscriber so the agent can reply; on custom-code / self-hosted agents, the turn is forwarded to the bridge with a null subscriber. "restricted" rejects unknown senders with a managed denial reply (any runtime). Unset resolves as "restricted". Managed agent create defaults to "open"; self-hosted create defaults to "restricted".
+ */
+export type SubscriberAccess = ClosedEnum<typeof SubscriberAccess>;
+
+export type AgentBehaviorDto = {
+  /**
+   * Acknowledge incoming messages. On platforms that support a native typing indicator (e.g. Slack, WhatsApp, Microsoft Teams, Telegram), shows a "Typing…" indicator while the agent processes the message. On platforms that do not (e.g. Email), reacts with an "eyes" emoji to the first inbound message in a thread. Default: true
+   */
+  acknowledgeOnReceived?: boolean | undefined;
+  /**
+   * Cross-platform emoji name for resolved conversations (e.g. "check", "star"). Set to null to disable. Default: "check"
+   */
+  reactionOnResolved?: ReactionOnResolved | null | undefined;
+  /**
+   * Controls whether the agent accepts inbound messages from senders not yet linked to a subscriber, across all channels. "open" on managed agents auto-creates a lightweight subscriber so the agent can reply; on custom-code / self-hosted agents, the turn is forwarded to the bridge with a null subscriber. "restricted" rejects unknown senders with a managed denial reply (any runtime). Unset resolves as "restricted". Managed agent create defaults to "open"; self-hosted create defaults to "restricted".
+   */
+  subscriberAccess?: SubscriberAccess | undefined;
+};
+
+/** @internal */
+export const ReactionOnResolved$inboundSchema: z.ZodType<
+  ReactionOnResolved,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type ReactionOnResolved$Outbound = {};
+
+/** @internal */
+export const ReactionOnResolved$outboundSchema: z.ZodType<
+  ReactionOnResolved$Outbound,
+  z.ZodTypeDef,
+  ReactionOnResolved
+> = z.object({});
+
+export function reactionOnResolvedToJSON(
+  reactionOnResolved: ReactionOnResolved,
+): string {
+  return JSON.stringify(
+    ReactionOnResolved$outboundSchema.parse(reactionOnResolved),
+  );
+}
+export function reactionOnResolvedFromJSON(
+  jsonString: string,
+): SafeParseResult<ReactionOnResolved, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReactionOnResolved$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReactionOnResolved' from JSON`,
+  );
+}
+
+/** @internal */
+export const SubscriberAccess$inboundSchema: z.ZodNativeEnum<
+  typeof SubscriberAccess
+> = z.nativeEnum(SubscriberAccess);
+/** @internal */
+export const SubscriberAccess$outboundSchema: z.ZodNativeEnum<
+  typeof SubscriberAccess
+> = SubscriberAccess$inboundSchema;
+
+/** @internal */
+export const AgentBehaviorDto$inboundSchema: z.ZodType<
+  AgentBehaviorDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  acknowledgeOnReceived: z.boolean().default(true),
+  reactionOnResolved: z.nullable(z.lazy(() => ReactionOnResolved$inboundSchema))
+    .optional(),
+  subscriberAccess: SubscriberAccess$inboundSchema.optional(),
+});
+/** @internal */
+export type AgentBehaviorDto$Outbound = {
+  acknowledgeOnReceived: boolean;
+  reactionOnResolved?: ReactionOnResolved$Outbound | null | undefined;
+  subscriberAccess?: string | undefined;
+};
+
+/** @internal */
+export const AgentBehaviorDto$outboundSchema: z.ZodType<
+  AgentBehaviorDto$Outbound,
+  z.ZodTypeDef,
+  AgentBehaviorDto
+> = z.object({
+  acknowledgeOnReceived: z.boolean().default(true),
+  reactionOnResolved: z.nullable(
+    z.lazy(() => ReactionOnResolved$outboundSchema),
+  ).optional(),
+  subscriberAccess: SubscriberAccess$outboundSchema.optional(),
+});
+
+export function agentBehaviorDtoToJSON(
+  agentBehaviorDto: AgentBehaviorDto,
+): string {
+  return JSON.stringify(
+    AgentBehaviorDto$outboundSchema.parse(agentBehaviorDto),
+  );
+}
+export function agentBehaviorDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentBehaviorDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentBehaviorDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentBehaviorDto' from JSON`,
+  );
+}

package/src/models/components/agentintegrationresponsedto.ts

@@ -0,0 +1,90 @@
+/*
+ * 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 {
+  AgentIntegrationResponseIntegrationDto,
+  AgentIntegrationResponseIntegrationDto$inboundSchema,
+} from "./agentintegrationresponseintegrationdto.js";
+
+/**
+ * Set when the agent–integration link received its first inbound webhook delivery.
+ */
+export type ConnectedAt = {};
+
+export type AgentIntegrationResponseDto = {
+  /**
+   * Agent–integration link document id.
+   */
+  id: string;
+  agentId: string;
+  integration: AgentIntegrationResponseIntegrationDto;
+  environmentId: string;
+  organizationId: string;
+  /**
+   * Set when the agent–integration link received its first inbound webhook delivery.
+   */
+  connectedAt?: ConnectedAt | null | undefined;
+  createdAt: string;
+  updatedAt: string;
+  /**
+   * Cloud only. `true` when this channel type (provider) falls outside the organization plan active-channel limit (by connection order). Active channels are counted per channel type, so multiple integrations of the same provider (e.g. several Slack workspaces) count as a single active channel. Over-limit channels keep their configuration but the agent will not respond on them until the plan is upgraded or older channel types are disconnected.
+   */
+  exceedsPlanLimit?: boolean | undefined;
+};
+
+/** @internal */
+export const ConnectedAt$inboundSchema: z.ZodType<
+  ConnectedAt,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function connectedAtFromJSON(
+  jsonString: string,
+): SafeParseResult<ConnectedAt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConnectedAt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConnectedAt' from JSON`,
+  );
+}
+
+/** @internal */
+export const AgentIntegrationResponseDto$inboundSchema: z.ZodType<
+  AgentIntegrationResponseDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  _agentId: z.string(),
+  integration: AgentIntegrationResponseIntegrationDto$inboundSchema,
+  _environmentId: z.string(),
+  _organizationId: z.string(),
+  connectedAt: z.nullable(z.lazy(() => ConnectedAt$inboundSchema)).optional(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  exceedsPlanLimit: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "_agentId": "agentId",
+    "_environmentId": "environmentId",
+    "_organizationId": "organizationId",
+  });
+});
+
+export function agentIntegrationResponseDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentIntegrationResponseDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentIntegrationResponseDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentIntegrationResponseDto' from JSON`,
+  );
+}

package/src/models/components/agentintegrationresponseintegrationdto.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";
+import {
+  ChannelTypeEnum,
+  ChannelTypeEnum$inboundSchema,
+} from "./channeltypeenum.js";
+
+export type AgentIntegrationResponseIntegrationDto = {
+  /**
+   * Integration document _id.
+   */
+  id: string;
+  /**
+   * The integration identifier (matches the integration store), not the internal MongoDB _id.
+   */
+  identifier: string;
+  name: string;
+  providerId: string;
+  /**
+   * Channel type through which the message is sent
+   */
+  channel?: ChannelTypeEnum | undefined;
+  active: boolean;
+  /**
+   * The Novu shared inbox address for this agent. Set whenever the cloud shared-inbox feature is enabled. The dashboard uses this as the headline inbound address and to render the shared inbox row in the inbox list.
+   */
+  sharedInboundAddress?: string | undefined;
+  /**
+   * Default email From display name for this agent (NovuAgent integrations only). Falls back to the agent name when not explicitly stored on the integration credentials.
+   */
+  defaultSenderName?: string | undefined;
+  /**
+   * When true, the worker drops inbound mail addressed to this agent on the shared `agentconnect.sh` domain. Custom-domain routes still deliver. Meaningful on cloud-enabled NovuAgent integrations; on self-hosted it is set defensively at provisioning time and is effectively redundant.
+   */
+  sharedInboxDisabled?: boolean | undefined;
+};
+
+/** @internal */
+export const AgentIntegrationResponseIntegrationDto$inboundSchema: z.ZodType<
+  AgentIntegrationResponseIntegrationDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  identifier: z.string(),
+  name: z.string(),
+  providerId: z.string(),
+  channel: ChannelTypeEnum$inboundSchema.optional(),
+  active: z.boolean(),
+  sharedInboundAddress: z.string().optional(),
+  defaultSenderName: z.string().optional(),
+  sharedInboxDisabled: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+  });
+});
+
+export function agentIntegrationResponseIntegrationDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentIntegrationResponseIntegrationDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      AgentIntegrationResponseIntegrationDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentIntegrationResponseIntegrationDto' from JSON`,
+  );
+}

package/src/models/components/agentintegrationsummarydto.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 {
+  ChannelTypeEnum,
+  ChannelTypeEnum$inboundSchema,
+} from "./channeltypeenum.js";
+
+export type AgentIntegrationSummaryDto = {
+  /**
+   * Integration document id.
+   */
+  integrationId: string;
+  providerId: string;
+  name: string;
+  identifier: string;
+  /**
+   * Channel type through which the message is sent
+   */
+  channel?: ChannelTypeEnum | undefined;
+  active: boolean;
+};
+
+/** @internal */
+export const AgentIntegrationSummaryDto$inboundSchema: z.ZodType<
+  AgentIntegrationSummaryDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  integrationId: z.string(),
+  providerId: z.string(),
+  name: z.string(),
+  identifier: z.string(),
+  channel: ChannelTypeEnum$inboundSchema.optional(),
+  active: z.boolean(),
+});
+
+export function agentIntegrationSummaryDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentIntegrationSummaryDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentIntegrationSummaryDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentIntegrationSummaryDto' from JSON`,
+  );
+}

package/src/models/components/agentmcpserverdto.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 AgentMcpServerDto = {
+  externalId: string;
+  name: string;
+  url: string;
+};
+
+/** @internal */
+export const AgentMcpServerDto$inboundSchema: z.ZodType<
+  AgentMcpServerDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  externalId: z.string(),
+  name: z.string(),
+  url: z.string(),
+});
+
+export function agentMcpServerDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentMcpServerDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentMcpServerDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentMcpServerDto' from JSON`,
+  );
+}

package/src/models/components/agentplanusagedto.ts

@@ -0,0 +1,71 @@
+/*
+ * 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";
+
+/**
+ * Which constraint produced the limits. `plan` limits are lifted by upgrading; `system` limits (platform cap or per-organization override) require contacting the Novu team.
+ */
+export const LimitSource = {
+  Plan: "plan",
+  System: "system",
+} as const;
+/**
+ * Which constraint produced the limits. `plan` limits are lifted by upgrading; `system` limits (platform cap or per-organization override) require contacting the Novu team.
+ */
+export type LimitSource = ClosedEnum<typeof LimitSource>;
+
+export type AgentPlanUsageDto = {
+  /**
+   * Current usage count for the resource in this environment.
+   */
+  used: number;
+  /**
+   * Amount included in the organization plan.
+   */
+  limit: number;
+  /**
+   * Total agents in this environment, including inactive ones.
+   */
+  totalCreated: number;
+  /**
+   * Hard cap on total agents the organization can create per environment. For plan-limited tiers this is the plan limit plus a small grace buffer; for unlimited tiers it is the platform system limit.
+   */
+  creationLimit: number;
+  /**
+   * Which constraint produced the limits. `plan` limits are lifted by upgrading; `system` limits (platform cap or per-organization override) require contacting the Novu team.
+   */
+  limitSource: LimitSource;
+};
+
+/** @internal */
+export const LimitSource$inboundSchema: z.ZodNativeEnum<typeof LimitSource> = z
+  .nativeEnum(LimitSource);
+
+/** @internal */
+export const AgentPlanUsageDto$inboundSchema: z.ZodType<
+  AgentPlanUsageDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  used: z.number(),
+  limit: z.number(),
+  totalCreated: z.number(),
+  creationLimit: z.number(),
+  limitSource: LimitSource$inboundSchema,
+});
+
+export function agentPlanUsageDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentPlanUsageDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentPlanUsageDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentPlanUsageDto' from JSON`,
+  );
+}