@novu/api 0.0.1-alpha.11 → 0.0.1-alpha.110

package/src/models/components/bulktriggereventdto.ts

@@ -3,6 +3,9 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   TriggerEventRequestDto,
   TriggerEventRequestDto$inboundSchema,
@@ -49,3 +52,21 @@ export namespace BulkTriggerEventDto$ {
   /** @deprecated use `BulkTriggerEventDto$Outbound` instead. */
   export type Outbound = BulkTriggerEventDto$Outbound;
 }
+
+export function bulkTriggerEventDtoToJSON(
+  bulkTriggerEventDto: BulkTriggerEventDto,
+): string {
+  return JSON.stringify(
+    BulkTriggerEventDto$outboundSchema.parse(bulkTriggerEventDto),
+  );
+}
+
+export function bulkTriggerEventDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<BulkTriggerEventDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BulkTriggerEventDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BulkTriggerEventDto' from JSON`,
+  );
+}

package/src/models/components/channelcredentials.ts

@@ -3,12 +3,15 @@
  */
 
 import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type ChannelCredentials = {
   /**
-   * alert_uid for grafana on-call webhook payload
+   * Webhook url used by chat app integrations. The webhook should be obtained from the chat app provider.
    */
-  alertUid?: string | undefined;
+  webhookUrl: string;
   /**
    * Channel specification for Mattermost chat notifications
    */
@@ -18,9 +21,13 @@ export type ChannelCredentials = {
    */
   deviceTokens?: Array<string> | undefined;
   /**
-   * link_to_upstream_details property fo grafana on call webhook
+   * alert_uid for grafana on-call webhook payload
    */
-  externalUrl?: string | undefined;
+  alertUid?: string | undefined;
+  /**
+   * title to be used with grafana on call webhook
+   */
+  title?: string | undefined;
   /**
    * image_url property fo grafana on call webhook
    */
@@ -30,13 +37,9 @@ export type ChannelCredentials = {
    */
   state?: string | undefined;
   /**
-   * title to be used with grafana on call webhook
-   */
-  title?: string | undefined;
-  /**
-   * Webhook url used by chat app integrations. The webhook should be obtained from the chat app provider.
+   * link_to_upstream_details property fo grafana on call webhook
    */
-  webhookUrl: string;
+  externalUrl?: string | undefined;
 };
 
 /** @internal */
@@ -45,26 +48,26 @@ export const ChannelCredentials$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  alertUid: z.string().optional(),
+  webhookUrl: z.string(),
   channel: z.string().optional(),
   deviceTokens: z.array(z.string()).optional(),
-  externalUrl: z.string().optional(),
+  alertUid: z.string().optional(),
+  title: z.string().optional(),
   imageUrl: z.string().optional(),
   state: z.string().optional(),
-  title: z.string().optional(),
-  webhookUrl: z.string(),
+  externalUrl: z.string().optional(),
 });
 
 /** @internal */
 export type ChannelCredentials$Outbound = {
-  alertUid?: string | undefined;
+  webhookUrl: string;
   channel?: string | undefined;
   deviceTokens?: Array<string> | undefined;
-  externalUrl?: string | undefined;
+  alertUid?: string | undefined;
+  title?: string | undefined;
   imageUrl?: string | undefined;
   state?: string | undefined;
-  title?: string | undefined;
-  webhookUrl: string;
+  externalUrl?: string | undefined;
 };
 
 /** @internal */
@@ -73,14 +76,14 @@ export const ChannelCredentials$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ChannelCredentials
 > = z.object({
-  alertUid: z.string().optional(),
+  webhookUrl: z.string(),
   channel: z.string().optional(),
   deviceTokens: z.array(z.string()).optional(),
-  externalUrl: z.string().optional(),
+  alertUid: z.string().optional(),
+  title: z.string().optional(),
   imageUrl: z.string().optional(),
   state: z.string().optional(),
-  title: z.string().optional(),
-  webhookUrl: z.string(),
+  externalUrl: z.string().optional(),
 });
 
 /**
@@ -95,3 +98,21 @@ export namespace ChannelCredentials$ {
   /** @deprecated use `ChannelCredentials$Outbound` instead. */
   export type Outbound = ChannelCredentials$Outbound;
 }
+
+export function channelCredentialsToJSON(
+  channelCredentials: ChannelCredentials,
+): string {
+  return JSON.stringify(
+    ChannelCredentials$outboundSchema.parse(channelCredentials),
+  );
+}
+
+export function channelCredentialsFromJSON(
+  jsonString: string,
+): SafeParseResult<ChannelCredentials, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ChannelCredentials$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChannelCredentials' from JSON`,
+  );
+}

package/src/models/components/channelcredentialsdto.ts

@@ -0,0 +1,76 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ChannelCredentialsDto = {
+  /**
+   * The URL for the webhook associated with the channel.
+   */
+  webhookUrl?: string | undefined;
+  /**
+   * An array of device tokens for push notifications.
+   */
+  deviceTokens?: Array<string> | undefined;
+};
+
+/** @internal */
+export const ChannelCredentialsDto$inboundSchema: z.ZodType<
+  ChannelCredentialsDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  webhookUrl: z.string().optional(),
+  deviceTokens: z.array(z.string()).optional(),
+});
+
+/** @internal */
+export type ChannelCredentialsDto$Outbound = {
+  webhookUrl?: string | undefined;
+  deviceTokens?: Array<string> | undefined;
+};
+
+/** @internal */
+export const ChannelCredentialsDto$outboundSchema: z.ZodType<
+  ChannelCredentialsDto$Outbound,
+  z.ZodTypeDef,
+  ChannelCredentialsDto
+> = z.object({
+  webhookUrl: z.string().optional(),
+  deviceTokens: z.array(z.string()).optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChannelCredentialsDto$ {
+  /** @deprecated use `ChannelCredentialsDto$inboundSchema` instead. */
+  export const inboundSchema = ChannelCredentialsDto$inboundSchema;
+  /** @deprecated use `ChannelCredentialsDto$outboundSchema` instead. */
+  export const outboundSchema = ChannelCredentialsDto$outboundSchema;
+  /** @deprecated use `ChannelCredentialsDto$Outbound` instead. */
+  export type Outbound = ChannelCredentialsDto$Outbound;
+}
+
+export function channelCredentialsDtoToJSON(
+  channelCredentialsDto: ChannelCredentialsDto,
+): string {
+  return JSON.stringify(
+    ChannelCredentialsDto$outboundSchema.parse(channelCredentialsDto),
+  );
+}
+
+export function channelCredentialsDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<ChannelCredentialsDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ChannelCredentialsDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChannelCredentialsDto' from JSON`,
+  );
+}

package/src/models/components/channelpreference.ts

@@ -3,12 +3,15 @@
  */
 
 import * as z from "zod";
+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";
 
 /**
  * The type of channel that is enabled or not
  */
-export const ChannelPreferenceType = {
+export const Type = {
   InApp: "in_app",
   Email: "email",
   Sms: "sms",
@@ -18,38 +21,37 @@ export const ChannelPreferenceType = {
 /**
  * The type of channel that is enabled or not
  */
-export type ChannelPreferenceType = ClosedEnum<typeof ChannelPreferenceType>;
+export type Type = ClosedEnum<typeof Type>;
 
 export type ChannelPreference = {
   /**
-   * If channel is enabled or not
+   * The type of channel that is enabled or not
    */
-  enabled: boolean;
+  type: Type;
   /**
-   * The type of channel that is enabled or not
+   * If channel is enabled or not
    */
-  type: ChannelPreferenceType;
+  enabled: boolean;
 };
 
 /** @internal */
-export const ChannelPreferenceType$inboundSchema: z.ZodNativeEnum<
-  typeof ChannelPreferenceType
-> = z.nativeEnum(ChannelPreferenceType);
+export const Type$inboundSchema: z.ZodNativeEnum<typeof Type> = z.nativeEnum(
+  Type,
+);
 
 /** @internal */
-export const ChannelPreferenceType$outboundSchema: z.ZodNativeEnum<
-  typeof ChannelPreferenceType
-> = ChannelPreferenceType$inboundSchema;
+export const Type$outboundSchema: z.ZodNativeEnum<typeof Type> =
+  Type$inboundSchema;
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ChannelPreferenceType$ {
-  /** @deprecated use `ChannelPreferenceType$inboundSchema` instead. */
-  export const inboundSchema = ChannelPreferenceType$inboundSchema;
-  /** @deprecated use `ChannelPreferenceType$outboundSchema` instead. */
-  export const outboundSchema = ChannelPreferenceType$outboundSchema;
+export namespace Type$ {
+  /** @deprecated use `Type$inboundSchema` instead. */
+  export const inboundSchema = Type$inboundSchema;
+  /** @deprecated use `Type$outboundSchema` instead. */
+  export const outboundSchema = Type$outboundSchema;
 }
 
 /** @internal */
@@ -58,14 +60,14 @@ export const ChannelPreference$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  type: Type$inboundSchema,
   enabled: z.boolean(),
-  type: ChannelPreferenceType$inboundSchema,
 });
 
 /** @internal */
 export type ChannelPreference$Outbound = {
-  enabled: boolean;
   type: string;
+  enabled: boolean;
 };
 
 /** @internal */
@@ -74,8 +76,8 @@ export const ChannelPreference$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ChannelPreference
 > = z.object({
+  type: Type$outboundSchema,
   enabled: z.boolean(),
-  type: ChannelPreferenceType$outboundSchema,
 });
 
 /**
@@ -90,3 +92,21 @@ export namespace ChannelPreference$ {
   /** @deprecated use `ChannelPreference$Outbound` instead. */
   export type Outbound = ChannelPreference$Outbound;
 }
+
+export function channelPreferenceToJSON(
+  channelPreference: ChannelPreference,
+): string {
+  return JSON.stringify(
+    ChannelPreference$outboundSchema.parse(channelPreference),
+  );
+}
+
+export function channelPreferenceFromJSON(
+  jsonString: string,
+): SafeParseResult<ChannelPreference, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ChannelPreference$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChannelPreference' from JSON`,
+  );
+}

package/src/models/components/channelsettings.ts

@@ -4,6 +4,10 @@
 
 import * as z from "zod";
 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 {
   ChannelCredentials,
   ChannelCredentials$inboundSchema,
@@ -11,35 +15,85 @@ import {
   ChannelCredentials$outboundSchema,
 } from "./channelcredentials.js";
 
+/**
+ * The provider identifier for the credentials
+ */
+export const ChannelSettingsProviderId = {
+  Slack: "slack",
+  Discord: "discord",
+  Msteams: "msteams",
+  Mattermost: "mattermost",
+  Ryver: "ryver",
+  Zulip: "zulip",
+  GrafanaOnCall: "grafana-on-call",
+  Getstream: "getstream",
+  RocketChat: "rocket-chat",
+  WhatsappBusiness: "whatsapp-business",
+  Fcm: "fcm",
+  Apns: "apns",
+  Expo: "expo",
+  OneSignal: "one-signal",
+  Pushpad: "pushpad",
+  PushWebhook: "push-webhook",
+  PusherBeams: "pusher-beams",
+} as const;
+/**
+ * The provider identifier for the credentials
+ */
+export type ChannelSettingsProviderId = ClosedEnum<
+  typeof ChannelSettingsProviderId
+>;
+
 export type ChannelSettings = {
   /**
-   * Id of the integration that is used for this channel
-   */
-  integrationId: string;
-  /**
-   * Credentials payload for the specified provider
+   * The provider identifier for the credentials
    */
-  credentials: ChannelCredentials;
+  providerId: ChannelSettingsProviderId;
   /**
    * The integration identifier
    */
   integrationIdentifier?: string | undefined;
   /**
-   * The provider identifier for the credentials
+   * Credentials payload for the specified provider
+   */
+  credentials: ChannelCredentials;
+  /**
+   * The unique identifier of the integration associated with this channel.
    */
-  providerId: number;
+  integrationId: string;
 };
 
+/** @internal */
+export const ChannelSettingsProviderId$inboundSchema: z.ZodNativeEnum<
+  typeof ChannelSettingsProviderId
+> = z.nativeEnum(ChannelSettingsProviderId);
+
+/** @internal */
+export const ChannelSettingsProviderId$outboundSchema: z.ZodNativeEnum<
+  typeof ChannelSettingsProviderId
+> = ChannelSettingsProviderId$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChannelSettingsProviderId$ {
+  /** @deprecated use `ChannelSettingsProviderId$inboundSchema` instead. */
+  export const inboundSchema = ChannelSettingsProviderId$inboundSchema;
+  /** @deprecated use `ChannelSettingsProviderId$outboundSchema` instead. */
+  export const outboundSchema = ChannelSettingsProviderId$outboundSchema;
+}
+
 /** @internal */
 export const ChannelSettings$inboundSchema: z.ZodType<
   ChannelSettings,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _integrationId: z.string(),
-  credentials: ChannelCredentials$inboundSchema,
+  providerId: ChannelSettingsProviderId$inboundSchema,
   integrationIdentifier: z.string().optional(),
-  providerId: z.number(),
+  credentials: ChannelCredentials$inboundSchema,
+  _integrationId: z.string(),
 }).transform((v) => {
   return remap$(v, {
     "_integrationId": "integrationId",
@@ -48,10 +102,10 @@ export const ChannelSettings$inboundSchema: z.ZodType<
 
 /** @internal */
 export type ChannelSettings$Outbound = {
-  _integrationId: string;
-  credentials: ChannelCredentials$Outbound;
+  providerId: string;
   integrationIdentifier?: string | undefined;
-  providerId: number;
+  credentials: ChannelCredentials$Outbound;
+  _integrationId: string;
 };
 
 /** @internal */
@@ -60,10 +114,10 @@ export const ChannelSettings$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ChannelSettings
 > = z.object({
-  integrationId: z.string(),
-  credentials: ChannelCredentials$outboundSchema,
+  providerId: ChannelSettingsProviderId$outboundSchema,
   integrationIdentifier: z.string().optional(),
-  providerId: z.number(),
+  credentials: ChannelCredentials$outboundSchema,
+  integrationId: z.string(),
 }).transform((v) => {
   return remap$(v, {
     integrationId: "_integrationId",
@@ -82,3 +136,19 @@ export namespace ChannelSettings$ {
   /** @deprecated use `ChannelSettings$Outbound` instead. */
   export type Outbound = ChannelSettings$Outbound;
 }
+
+export function channelSettingsToJSON(
+  channelSettings: ChannelSettings,
+): string {
+  return JSON.stringify(ChannelSettings$outboundSchema.parse(channelSettings));
+}
+
+export function channelSettingsFromJSON(
+  jsonString: string,
+): SafeParseResult<ChannelSettings, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ChannelSettings$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChannelSettings' from JSON`,
+  );
+}

package/src/models/components/channeltypeenum.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * The channel through which the notification is sent.
+ */
+export const ChannelTypeEnum = {
+  InApp: "in_app",
+  Email: "email",
+  Sms: "sms",
+  Chat: "chat",
+  Push: "push",
+} as const;
+/**
+ * The channel through which the notification is sent.
+ */
+export type ChannelTypeEnum = ClosedEnum<typeof ChannelTypeEnum>;
+
+/** @internal */
+export const ChannelTypeEnum$inboundSchema: z.ZodNativeEnum<
+  typeof ChannelTypeEnum
+> = z.nativeEnum(ChannelTypeEnum);
+
+/** @internal */
+export const ChannelTypeEnum$outboundSchema: z.ZodNativeEnum<
+  typeof ChannelTypeEnum
+> = ChannelTypeEnum$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChannelTypeEnum$ {
+  /** @deprecated use `ChannelTypeEnum$inboundSchema` instead. */
+  export const inboundSchema = ChannelTypeEnum$inboundSchema;
+  /** @deprecated use `ChannelTypeEnum$outboundSchema` instead. */
+  export const outboundSchema = ChannelTypeEnum$outboundSchema;
+}