@novu/api 0.0.1-alpha.191 → 0.0.1-alpha.193

package/src/models/components/activitynotificationstepresponsedto.ts

@@ -14,11 +14,31 @@ import {
   MessageTemplateDto$outboundSchema,
 } from "./messagetemplatedto.js";
 import {
-  StepFilter,
-  StepFilter$inboundSchema,
-  StepFilter$Outbound,
-  StepFilter$outboundSchema,
-} from "./stepfilter.js";
+  StepFilterDto,
+  StepFilterDto$inboundSchema,
+  StepFilterDto$Outbound,
+  StepFilterDto$outboundSchema,
+} from "./stepfilterdto.js";
+
+/**
+ * Reply callback settings
+ */
+export type ActivityNotificationStepResponseDtoReplyCallback = {};
+
+/**
+ * Control variables
+ */
+export type ControlVariables = {};
+
+/**
+ * Metadata for the workflow step
+ */
+export type Metadata = {};
+
+/**
+ * Step issues
+ */
+export type Issues = {};
 
 export type ActivityNotificationStepResponseDto = {
   /**
@@ -29,16 +49,243 @@ export type ActivityNotificationStepResponseDto = {
    * Whether the step is active or not
    */
   active: boolean;
+  /**
+   * Reply callback settings
+   */
+  replyCallback?: ActivityNotificationStepResponseDtoReplyCallback | undefined;
+  /**
+   * Control variables
+   */
+  controlVariables?: ControlVariables | undefined;
+  /**
+   * Metadata for the workflow step
+   */
+  metadata?: Metadata | undefined;
+  /**
+   * Step issues
+   */
+  issues?: Issues | undefined;
   /**
    * Filter criteria for the step
    */
-  filters: Array<StepFilter>;
+  filters: Array<StepFilterDto>;
   /**
    * Optional template for the step
    */
   template?: MessageTemplateDto | undefined;
+  /**
+   * Variants of the step
+   */
+  variants?: Array<ActivityNotificationStepResponseDto> | undefined;
+  /**
+   * The identifier for the template associated with this step
+   */
+  templateId: string;
+  /**
+   * The name of the step
+   */
+  name?: string | undefined;
+  /**
+   * The unique identifier for the parent step
+   */
+  parentId?: string | null | undefined;
 };
 
+/** @internal */
+export const ActivityNotificationStepResponseDtoReplyCallback$inboundSchema:
+  z.ZodType<
+    ActivityNotificationStepResponseDtoReplyCallback,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({});
+
+/** @internal */
+export type ActivityNotificationStepResponseDtoReplyCallback$Outbound = {};
+
+/** @internal */
+export const ActivityNotificationStepResponseDtoReplyCallback$outboundSchema:
+  z.ZodType<
+    ActivityNotificationStepResponseDtoReplyCallback$Outbound,
+    z.ZodTypeDef,
+    ActivityNotificationStepResponseDtoReplyCallback
+  > = z.object({});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ActivityNotificationStepResponseDtoReplyCallback$ {
+  /** @deprecated use `ActivityNotificationStepResponseDtoReplyCallback$inboundSchema` instead. */
+  export const inboundSchema =
+    ActivityNotificationStepResponseDtoReplyCallback$inboundSchema;
+  /** @deprecated use `ActivityNotificationStepResponseDtoReplyCallback$outboundSchema` instead. */
+  export const outboundSchema =
+    ActivityNotificationStepResponseDtoReplyCallback$outboundSchema;
+  /** @deprecated use `ActivityNotificationStepResponseDtoReplyCallback$Outbound` instead. */
+  export type Outbound =
+    ActivityNotificationStepResponseDtoReplyCallback$Outbound;
+}
+
+export function activityNotificationStepResponseDtoReplyCallbackToJSON(
+  activityNotificationStepResponseDtoReplyCallback:
+    ActivityNotificationStepResponseDtoReplyCallback,
+): string {
+  return JSON.stringify(
+    ActivityNotificationStepResponseDtoReplyCallback$outboundSchema.parse(
+      activityNotificationStepResponseDtoReplyCallback,
+    ),
+  );
+}
+
+export function activityNotificationStepResponseDtoReplyCallbackFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ActivityNotificationStepResponseDtoReplyCallback,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ActivityNotificationStepResponseDtoReplyCallback$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ActivityNotificationStepResponseDtoReplyCallback' from JSON`,
+  );
+}
+
+/** @internal */
+export const ControlVariables$inboundSchema: z.ZodType<
+  ControlVariables,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+/** @internal */
+export type ControlVariables$Outbound = {};
+
+/** @internal */
+export const ControlVariables$outboundSchema: z.ZodType<
+  ControlVariables$Outbound,
+  z.ZodTypeDef,
+  ControlVariables
+> = z.object({});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ControlVariables$ {
+  /** @deprecated use `ControlVariables$inboundSchema` instead. */
+  export const inboundSchema = ControlVariables$inboundSchema;
+  /** @deprecated use `ControlVariables$outboundSchema` instead. */
+  export const outboundSchema = ControlVariables$outboundSchema;
+  /** @deprecated use `ControlVariables$Outbound` instead. */
+  export type Outbound = ControlVariables$Outbound;
+}
+
+export function controlVariablesToJSON(
+  controlVariables: ControlVariables,
+): string {
+  return JSON.stringify(
+    ControlVariables$outboundSchema.parse(controlVariables),
+  );
+}
+
+export function controlVariablesFromJSON(
+  jsonString: string,
+): SafeParseResult<ControlVariables, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ControlVariables$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ControlVariables' from JSON`,
+  );
+}
+
+/** @internal */
+export const Metadata$inboundSchema: z.ZodType<
+  Metadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+/** @internal */
+export type Metadata$Outbound = {};
+
+/** @internal */
+export const Metadata$outboundSchema: z.ZodType<
+  Metadata$Outbound,
+  z.ZodTypeDef,
+  Metadata
+> = z.object({});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Metadata$ {
+  /** @deprecated use `Metadata$inboundSchema` instead. */
+  export const inboundSchema = Metadata$inboundSchema;
+  /** @deprecated use `Metadata$outboundSchema` instead. */
+  export const outboundSchema = Metadata$outboundSchema;
+  /** @deprecated use `Metadata$Outbound` instead. */
+  export type Outbound = Metadata$Outbound;
+}
+
+export function metadataToJSON(metadata: Metadata): string {
+  return JSON.stringify(Metadata$outboundSchema.parse(metadata));
+}
+
+export function metadataFromJSON(
+  jsonString: string,
+): SafeParseResult<Metadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Metadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Metadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const Issues$inboundSchema: z.ZodType<Issues, z.ZodTypeDef, unknown> = z
+  .object({});
+
+/** @internal */
+export type Issues$Outbound = {};
+
+/** @internal */
+export const Issues$outboundSchema: z.ZodType<
+  Issues$Outbound,
+  z.ZodTypeDef,
+  Issues
+> = z.object({});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Issues$ {
+  /** @deprecated use `Issues$inboundSchema` instead. */
+  export const inboundSchema = Issues$inboundSchema;
+  /** @deprecated use `Issues$outboundSchema` instead. */
+  export const outboundSchema = Issues$outboundSchema;
+  /** @deprecated use `Issues$Outbound` instead. */
+  export type Outbound = Issues$Outbound;
+}
+
+export function issuesToJSON(issues: Issues): string {
+  return JSON.stringify(Issues$outboundSchema.parse(issues));
+}
+
+export function issuesFromJSON(
+  jsonString: string,
+): SafeParseResult<Issues, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Issues$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Issues' from JSON`,
+  );
+}
+
 /** @internal */
 export const ActivityNotificationStepResponseDto$inboundSchema: z.ZodType<
   ActivityNotificationStepResponseDto,
@@ -47,11 +294,25 @@ export const ActivityNotificationStepResponseDto$inboundSchema: z.ZodType<
 > = z.object({
   _id: z.string(),
   active: z.boolean(),
-  filters: z.array(StepFilter$inboundSchema),
+  replyCallback: z.lazy(() =>
+    ActivityNotificationStepResponseDtoReplyCallback$inboundSchema
+  ).optional(),
+  controlVariables: z.lazy(() => ControlVariables$inboundSchema).optional(),
+  metadata: z.lazy(() => Metadata$inboundSchema).optional(),
+  issues: z.lazy(() => Issues$inboundSchema).optional(),
+  filters: z.array(StepFilterDto$inboundSchema),
   template: MessageTemplateDto$inboundSchema.optional(),
+  variants: z.array(
+    z.lazy(() => ActivityNotificationStepResponseDto$inboundSchema),
+  ).optional(),
+  _templateId: z.string(),
+  name: z.string().optional(),
+  _parentId: z.nullable(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "_id": "id",
+    "_templateId": "templateId",
+    "_parentId": "parentId",
   });
 });
 
@@ -59,8 +320,18 @@ export const ActivityNotificationStepResponseDto$inboundSchema: z.ZodType<
 export type ActivityNotificationStepResponseDto$Outbound = {
   _id: string;
   active: boolean;
-  filters: Array<StepFilter$Outbound>;
+  replyCallback?:
+    | ActivityNotificationStepResponseDtoReplyCallback$Outbound
+    | undefined;
+  controlVariables?: ControlVariables$Outbound | undefined;
+  metadata?: Metadata$Outbound | undefined;
+  issues?: Issues$Outbound | undefined;
+  filters: Array<StepFilterDto$Outbound>;
   template?: MessageTemplateDto$Outbound | undefined;
+  variants?: Array<ActivityNotificationStepResponseDto$Outbound> | undefined;
+  _templateId: string;
+  name?: string | undefined;
+  _parentId?: string | null | undefined;
 };
 
 /** @internal */
@@ -71,11 +342,25 @@ export const ActivityNotificationStepResponseDto$outboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   active: z.boolean(),
-  filters: z.array(StepFilter$outboundSchema),
+  replyCallback: z.lazy(() =>
+    ActivityNotificationStepResponseDtoReplyCallback$outboundSchema
+  ).optional(),
+  controlVariables: z.lazy(() => ControlVariables$outboundSchema).optional(),
+  metadata: z.lazy(() => Metadata$outboundSchema).optional(),
+  issues: z.lazy(() => Issues$outboundSchema).optional(),
+  filters: z.array(StepFilterDto$outboundSchema),
   template: MessageTemplateDto$outboundSchema.optional(),
+  variants: z.array(
+    z.lazy(() => ActivityNotificationStepResponseDto$outboundSchema),
+  ).optional(),
+  templateId: z.string(),
+  name: z.string().optional(),
+  parentId: z.nullable(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     id: "_id",
+    templateId: "_templateId",
+    parentId: "_parentId",
   });
 });
 

package/src/models/components/activitynotificationtemplateresponsedto.ts

@@ -8,11 +8,11 @@ import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
-  NotificationTrigger,
-  NotificationTrigger$inboundSchema,
-  NotificationTrigger$Outbound,
-  NotificationTrigger$outboundSchema,
-} from "./notificationtrigger.js";
+  NotificationTriggerDto,
+  NotificationTriggerDto$inboundSchema,
+  NotificationTriggerDto$Outbound,
+  NotificationTriggerDto$outboundSchema,
+} from "./notificationtriggerdto.js";
 
 export type ActivityNotificationTemplateResponseDto = {
   /**
@@ -26,7 +26,7 @@ export type ActivityNotificationTemplateResponseDto = {
   /**
    * Triggers of the template
    */
-  triggers: Array<NotificationTrigger>;
+  triggers: Array<NotificationTriggerDto>;
 };
 
 /** @internal */
@@ -37,7 +37,7 @@ export const ActivityNotificationTemplateResponseDto$inboundSchema: z.ZodType<
 > = z.object({
   _id: z.string().optional(),
   name: z.string(),
-  triggers: z.array(NotificationTrigger$inboundSchema),
+  triggers: z.array(NotificationTriggerDto$inboundSchema),
 }).transform((v) => {
   return remap$(v, {
     "_id": "id",
@@ -48,7 +48,7 @@ export const ActivityNotificationTemplateResponseDto$inboundSchema: z.ZodType<
 export type ActivityNotificationTemplateResponseDto$Outbound = {
   _id?: string | undefined;
   name: string;
-  triggers: Array<NotificationTrigger$Outbound>;
+  triggers: Array<NotificationTriggerDto$Outbound>;
 };
 
 /** @internal */
@@ -59,7 +59,7 @@ export const ActivityNotificationTemplateResponseDto$outboundSchema: z.ZodType<
 > = z.object({
   id: z.string().optional(),
   name: z.string(),
-  triggers: z.array(NotificationTrigger$outboundSchema),
+  triggers: z.array(NotificationTriggerDto$outboundSchema),
 }).transform((v) => {
   return remap$(v, {
     id: "_id",

package/src/models/components/builderfieldtypeenum.ts

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const BuilderFieldTypeEnum = {
+  Boolean: "BOOLEAN",
+  Text: "TEXT",
+  Date: "DATE",
+  Number: "NUMBER",
+  Statement: "STATEMENT",
+  List: "LIST",
+  MultiList: "MULTI_LIST",
+  Group: "GROUP",
+} as const;
+export type BuilderFieldTypeEnum = ClosedEnum<typeof BuilderFieldTypeEnum>;
+
+/** @internal */
+export const BuilderFieldTypeEnum$inboundSchema: z.ZodNativeEnum<
+  typeof BuilderFieldTypeEnum
+> = z.nativeEnum(BuilderFieldTypeEnum);
+
+/** @internal */
+export const BuilderFieldTypeEnum$outboundSchema: z.ZodNativeEnum<
+  typeof BuilderFieldTypeEnum
+> = BuilderFieldTypeEnum$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace BuilderFieldTypeEnum$ {
+  /** @deprecated use `BuilderFieldTypeEnum$inboundSchema` instead. */
+  export const inboundSchema = BuilderFieldTypeEnum$inboundSchema;
+  /** @deprecated use `BuilderFieldTypeEnum$outboundSchema` instead. */
+  export const outboundSchema = BuilderFieldTypeEnum$outboundSchema;
+}

package/src/models/components/digestmetadatadto.ts

@@ -0,0 +1,185 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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";
+import {
+  DigestTimedConfigDto,
+  DigestTimedConfigDto$inboundSchema,
+  DigestTimedConfigDto$Outbound,
+  DigestTimedConfigDto$outboundSchema,
+} from "./digesttimedconfigdto.js";
+import {
+  DigestTypeEnum,
+  DigestTypeEnum$inboundSchema,
+  DigestTypeEnum$outboundSchema,
+} from "./digesttypeenum.js";
+import {
+  DigestUnitEnum,
+  DigestUnitEnum$inboundSchema,
+  DigestUnitEnum$outboundSchema,
+} from "./digestunitenum.js";
+
+/**
+ * Unit of the digest
+ */
+export const Unit = {
+  Seconds: "seconds",
+  Minutes: "minutes",
+  Hours: "hours",
+  Days: "days",
+  Weeks: "weeks",
+  Months: "months",
+} as const;
+/**
+ * Unit of the digest
+ */
+export type Unit = ClosedEnum<typeof Unit>;
+
+export type DigestMetadataDto = {
+  /**
+   * Optional key for the digest
+   */
+  digestKey?: string | undefined;
+  /**
+   * Amount for the digest
+   */
+  amount?: number | undefined;
+  /**
+   * Unit of the digest
+   */
+  unit?: Unit | undefined;
+  /**
+   * The Digest Type
+   */
+  type: DigestTypeEnum;
+  /**
+   * Optional array of events associated with the digest, represented as key-value pairs
+   */
+  events?: Array<{ [k: string]: any }> | undefined;
+  /**
+   * Regular digest: Indicates if backoff is enabled for the regular digest
+   */
+  backoff?: boolean | undefined;
+  /**
+   * Regular digest: Amount for backoff
+   */
+  backoffAmount?: number | undefined;
+  /**
+   * Regular digest: Unit for backoff
+   */
+  backoffUnit?: DigestUnitEnum | undefined;
+  /**
+   * Regular digest: Indicates if the digest should update
+   */
+  updateMode?: boolean | undefined;
+  /**
+   * Configuration for timed digest
+   */
+  timed?: DigestTimedConfigDto | undefined;
+};
+
+/** @internal */
+export const Unit$inboundSchema: z.ZodNativeEnum<typeof Unit> = z.nativeEnum(
+  Unit,
+);
+
+/** @internal */
+export const Unit$outboundSchema: z.ZodNativeEnum<typeof Unit> =
+  Unit$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Unit$ {
+  /** @deprecated use `Unit$inboundSchema` instead. */
+  export const inboundSchema = Unit$inboundSchema;
+  /** @deprecated use `Unit$outboundSchema` instead. */
+  export const outboundSchema = Unit$outboundSchema;
+}
+
+/** @internal */
+export const DigestMetadataDto$inboundSchema: z.ZodType<
+  DigestMetadataDto,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  digestKey: z.string().optional(),
+  amount: z.number().optional(),
+  unit: Unit$inboundSchema.optional(),
+  type: DigestTypeEnum$inboundSchema,
+  events: z.array(z.record(z.any())).optional(),
+  backoff: z.boolean().optional(),
+  backoffAmount: z.number().optional(),
+  backoffUnit: DigestUnitEnum$inboundSchema.optional(),
+  updateMode: z.boolean().optional(),
+  timed: DigestTimedConfigDto$inboundSchema.optional(),
+});
+
+/** @internal */
+export type DigestMetadataDto$Outbound = {
+  digestKey?: string | undefined;
+  amount?: number | undefined;
+  unit?: string | undefined;
+  type: string;
+  events?: Array<{ [k: string]: any }> | undefined;
+  backoff?: boolean | undefined;
+  backoffAmount?: number | undefined;
+  backoffUnit?: string | undefined;
+  updateMode?: boolean | undefined;
+  timed?: DigestTimedConfigDto$Outbound | undefined;
+};
+
+/** @internal */
+export const DigestMetadataDto$outboundSchema: z.ZodType<
+  DigestMetadataDto$Outbound,
+  z.ZodTypeDef,
+  DigestMetadataDto
+> = z.object({
+  digestKey: z.string().optional(),
+  amount: z.number().optional(),
+  unit: Unit$outboundSchema.optional(),
+  type: DigestTypeEnum$outboundSchema,
+  events: z.array(z.record(z.any())).optional(),
+  backoff: z.boolean().optional(),
+  backoffAmount: z.number().optional(),
+  backoffUnit: DigestUnitEnum$outboundSchema.optional(),
+  updateMode: z.boolean().optional(),
+  timed: DigestTimedConfigDto$outboundSchema.optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DigestMetadataDto$ {
+  /** @deprecated use `DigestMetadataDto$inboundSchema` instead. */
+  export const inboundSchema = DigestMetadataDto$inboundSchema;
+  /** @deprecated use `DigestMetadataDto$outboundSchema` instead. */
+  export const outboundSchema = DigestMetadataDto$outboundSchema;
+  /** @deprecated use `DigestMetadataDto$Outbound` instead. */
+  export type Outbound = DigestMetadataDto$Outbound;
+}
+
+export function digestMetadataDtoToJSON(
+  digestMetadataDto: DigestMetadataDto,
+): string {
+  return JSON.stringify(
+    DigestMetadataDto$outboundSchema.parse(digestMetadataDto),
+  );
+}
+
+export function digestMetadataDtoFromJSON(
+  jsonString: string,
+): SafeParseResult<DigestMetadataDto, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DigestMetadataDto$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DigestMetadataDto' from JSON`,
+  );
+}