@astralibx/email-rule-engine 1.2.2 → 3.0.1

package/dist/index.d.mts

@@ -0,0 +1,607 @@
+import * as mongoose from 'mongoose';
+import { Connection, Model, HydratedDocument, Schema, Types } from 'mongoose';
+import { Redis } from 'ioredis';
+import { LogAdapter, AlxError } from '@astralibx/core';
+export { LogAdapter } from '@astralibx/core';
+import { Router } from 'express';
+
+declare const TEMPLATE_CATEGORY: {
+    readonly Onboarding: "onboarding";
+    readonly Engagement: "engagement";
+    readonly Transactional: "transactional";
+    readonly ReEngagement: "re-engagement";
+    readonly Announcement: "announcement";
+};
+type TemplateCategory = (typeof TEMPLATE_CATEGORY)[keyof typeof TEMPLATE_CATEGORY];
+declare const TEMPLATE_AUDIENCE: {
+    readonly Customer: "customer";
+    readonly Provider: "provider";
+    readonly All: "all";
+};
+type TemplateAudience = (typeof TEMPLATE_AUDIENCE)[keyof typeof TEMPLATE_AUDIENCE];
+declare const RULE_OPERATOR: {
+    readonly Eq: "eq";
+    readonly Neq: "neq";
+    readonly Gt: "gt";
+    readonly Gte: "gte";
+    readonly Lt: "lt";
+    readonly Lte: "lte";
+    readonly Exists: "exists";
+    readonly NotExists: "not_exists";
+    readonly In: "in";
+    readonly NotIn: "not_in";
+    readonly Contains: "contains";
+};
+type RuleOperator = (typeof RULE_OPERATOR)[keyof typeof RULE_OPERATOR];
+declare const EMAIL_TYPE: {
+    readonly Automated: "automated";
+    readonly Transactional: "transactional";
+};
+type EmailType = (typeof EMAIL_TYPE)[keyof typeof EMAIL_TYPE];
+declare const RUN_TRIGGER: {
+    readonly Cron: "cron";
+    readonly Manual: "manual";
+};
+type RunTrigger = (typeof RUN_TRIGGER)[keyof typeof RUN_TRIGGER];
+declare const THROTTLE_WINDOW: {
+    readonly Rolling: "rolling";
+};
+type ThrottleWindow = (typeof THROTTLE_WINDOW)[keyof typeof THROTTLE_WINDOW];
+declare const EMAIL_SEND_STATUS: {
+    readonly Sent: "sent";
+    readonly Error: "error";
+    readonly Skipped: "skipped";
+    readonly Invalid: "invalid";
+    readonly Throttled: "throttled";
+};
+type EmailSendStatus = (typeof EMAIL_SEND_STATUS)[keyof typeof EMAIL_SEND_STATUS];
+
+interface RuleCondition {
+    field: string;
+    operator: RuleOperator;
+    value: unknown;
+}
+interface RuleRunStats {
+    matched: number;
+    sent: number;
+    skipped: number;
+    skippedByThrottle: number;
+    errors: number;
+}
+interface RuleTarget {
+    role: TemplateAudience;
+    platform: string;
+    conditions: RuleCondition[];
+}
+interface EmailRule {
+    _id: string;
+    name: string;
+    description?: string;
+    isActive: boolean;
+    sortOrder: number;
+    target: RuleTarget;
+    templateId: string;
+    sendOnce: boolean;
+    resendAfterDays?: number;
+    cooldownDays?: number;
+    autoApprove: boolean;
+    maxPerRun?: number;
+    bypassThrottle: boolean;
+    emailType: EmailType;
+    totalSent: number;
+    totalSkipped: number;
+    lastRunAt?: Date;
+    lastRunStats?: RuleRunStats;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface CreateEmailRuleInput {
+    name: string;
+    description?: string;
+    target: RuleTarget;
+    templateId: string;
+    sortOrder?: number;
+    sendOnce?: boolean;
+    resendAfterDays?: number;
+    cooldownDays?: number;
+    autoApprove?: boolean;
+    maxPerRun?: number;
+    bypassThrottle?: boolean;
+    emailType?: EmailType;
+}
+interface UpdateEmailRuleInput {
+    name?: string;
+    description?: string;
+    isActive?: boolean;
+    sortOrder?: number;
+    target?: RuleTarget;
+    templateId?: string;
+    sendOnce?: boolean;
+    resendAfterDays?: number;
+    cooldownDays?: number;
+    autoApprove?: boolean;
+    maxPerRun?: number;
+    bypassThrottle?: boolean;
+    emailType?: EmailType;
+}
+interface EmailRuleSend {
+    _id: string;
+    ruleId: string;
+    userId: string;
+    emailIdentifierId?: string;
+    messageId?: string;
+    sentAt: Date;
+    status?: string;
+    accountId?: string;
+    senderName?: string;
+    subject?: string;
+    failureReason?: string;
+}
+interface PerRuleStats extends RuleRunStats {
+    ruleId: string;
+    ruleName: string;
+}
+interface EmailRuleRunLog {
+    _id: string;
+    runAt: Date;
+    triggeredBy: RunTrigger;
+    duration: number;
+    rulesProcessed: number;
+    totalStats: RuleRunStats;
+    perRuleStats: PerRuleStats[];
+}
+
+interface SendEmailParams {
+    identifierId: string;
+    contactId: string;
+    accountId: string;
+    subject: string;
+    htmlBody: string;
+    textBody: string;
+    ruleId: string;
+    autoApprove: boolean;
+}
+interface AgentSelection {
+    accountId: string;
+}
+interface RecipientIdentifier {
+    id: string;
+    contactId: string;
+}
+interface EmailRuleEngineConfig {
+    db: {
+        connection: Connection;
+        collectionPrefix?: string;
+    };
+    redis: {
+        connection: Redis;
+        keyPrefix?: string;
+    };
+    adapters: {
+        queryUsers: (target: RuleTarget, limit: number) => Promise<Record<string, unknown>[]>;
+        resolveData: (user: Record<string, unknown>) => Record<string, unknown>;
+        sendEmail: (params: SendEmailParams) => Promise<void>;
+        selectAgent: (identifierId: string, context?: {
+            ruleId: string;
+            templateId: string;
+        }) => Promise<AgentSelection | null>;
+        findIdentifier: (email: string) => Promise<RecipientIdentifier | null>;
+        sendTestEmail?: (to: string, subject: string, html: string, text: string) => Promise<void>;
+    };
+    platforms?: string[];
+    audiences?: string[];
+    categories?: string[];
+    logger?: LogAdapter;
+    options?: {
+        lockTTLMs?: number;
+        defaultMaxPerRun?: number;
+        sendWindow?: {
+            startHour: number;
+            endHour: number;
+            timezone: string;
+        };
+        delayBetweenSendsMs?: number;
+        jitterMs?: number;
+    };
+    hooks?: {
+        onRunStart?: (info: {
+            rulesCount: number;
+            triggeredBy: string;
+        }) => void;
+        onRuleStart?: (info: {
+            ruleId: string;
+            ruleName: string;
+            matchedCount: number;
+        }) => void;
+        onSend?: (info: {
+            ruleId: string;
+            ruleName: string;
+            email: string;
+            status: 'sent' | 'error' | 'skipped' | 'invalid' | 'throttled';
+        }) => void;
+        onRuleComplete?: (info: {
+            ruleId: string;
+            ruleName: string;
+            stats: RuleRunStats;
+        }) => void;
+        onRunComplete?: (info: {
+            duration: number;
+            totalStats: RuleRunStats;
+            perRuleStats: PerRuleStats[];
+        }) => void;
+    };
+}
+
+interface EmailTemplate {
+    _id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    category: TemplateCategory;
+    audience: TemplateAudience;
+    platform: string;
+    subject: string;
+    body: string;
+    textBody?: string;
+    variables: string[];
+    version: number;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface CreateEmailTemplateInput {
+    name: string;
+    slug: string;
+    description?: string;
+    category: TemplateCategory;
+    audience: TemplateAudience;
+    platform: string;
+    subject: string;
+    body: string;
+    textBody?: string;
+    variables?: string[];
+}
+interface UpdateEmailTemplateInput {
+    name?: string;
+    description?: string;
+    category?: TemplateCategory;
+    audience?: TemplateAudience;
+    platform?: string;
+    subject?: string;
+    body?: string;
+    textBody?: string;
+    variables?: string[];
+    isActive?: boolean;
+}
+
+interface IEmailTemplate extends Omit<EmailTemplate, '_id'> {
+}
+type EmailTemplateDocument = HydratedDocument<IEmailTemplate>;
+interface EmailTemplateStatics {
+    findBySlug(slug: string): Promise<EmailTemplateDocument | null>;
+    findActive(): Promise<EmailTemplateDocument[]>;
+    findByCategory(category: TemplateCategory): Promise<EmailTemplateDocument[]>;
+    findByAudience(audience: TemplateAudience): Promise<EmailTemplateDocument[]>;
+    createTemplate(input: CreateEmailTemplateInput): Promise<EmailTemplateDocument>;
+}
+type EmailTemplateModel = Model<IEmailTemplate> & EmailTemplateStatics;
+declare function createEmailTemplateSchema(platformValues?: string[], audienceValues?: string[], categoryValues?: string[], collectionPrefix?: string): Schema<IEmailTemplate, Model<IEmailTemplate, any, any, any, mongoose.Document<unknown, any, IEmailTemplate, any, {}> & IEmailTemplate & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IEmailTemplate, mongoose.Document<unknown, {}, mongoose.FlatRecord<IEmailTemplate>, {}, mongoose.DefaultSchemaOptions> & mongoose.FlatRecord<IEmailTemplate> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+
+interface IEmailRule extends Omit<EmailRule, '_id' | 'templateId'> {
+    templateId: Types.ObjectId;
+}
+type EmailRuleDocument = HydratedDocument<IEmailRule>;
+interface EmailRuleStatics {
+    findActive(): Promise<EmailRuleDocument[]>;
+    findByTemplateId(templateId: string | Types.ObjectId): Promise<EmailRuleDocument[]>;
+    createRule(input: CreateEmailRuleInput): Promise<EmailRuleDocument>;
+}
+type EmailRuleModel = Model<IEmailRule> & EmailRuleStatics;
+declare function createEmailRuleSchema(platformValues?: string[], audienceValues?: string[], collectionPrefix?: string): Schema<IEmailRule, Model<IEmailRule, any, any, any, mongoose.Document<unknown, any, IEmailRule, any, {}> & IEmailRule & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IEmailRule, mongoose.Document<unknown, {}, mongoose.FlatRecord<IEmailRule>, {}, mongoose.DefaultSchemaOptions> & mongoose.FlatRecord<IEmailRule> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+
+interface IEmailRuleSend {
+    ruleId: Types.ObjectId;
+    userId: Types.ObjectId;
+    emailIdentifierId?: Types.ObjectId;
+    messageId?: Types.ObjectId;
+    sentAt: Date;
+    status?: string;
+    accountId?: string;
+    senderName?: string;
+    subject?: string;
+    failureReason?: string;
+}
+type EmailRuleSendDocument = HydratedDocument<IEmailRuleSend>;
+interface EmailRuleSendStatics {
+    findLatestForUser(ruleId: string | Types.ObjectId, userId: string | Types.ObjectId): Promise<EmailRuleSendDocument | null>;
+    findRecentByUserIds(userIds: (string | Types.ObjectId)[], sinceDays: number): Promise<EmailRuleSendDocument[]>;
+    logSend(ruleId: string | Types.ObjectId, userId: string | Types.ObjectId, emailIdentifierId?: string | Types.ObjectId, messageId?: string | Types.ObjectId, extra?: {
+        status?: string;
+        accountId?: string;
+        senderName?: string;
+        subject?: string;
+        failureReason?: string;
+    }): Promise<EmailRuleSendDocument>;
+}
+type EmailRuleSendModel = Model<IEmailRuleSend> & EmailRuleSendStatics;
+declare function createEmailRuleSendSchema(collectionPrefix?: string): Schema<IEmailRuleSend, Model<IEmailRuleSend, any, any, any, mongoose.Document<unknown, any, IEmailRuleSend, any, {}> & IEmailRuleSend & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IEmailRuleSend, mongoose.Document<unknown, {}, mongoose.FlatRecord<IEmailRuleSend>, {}, mongoose.DefaultSchemaOptions> & mongoose.FlatRecord<IEmailRuleSend> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+
+interface IEmailRuleRunLog {
+    runAt: Date;
+    triggeredBy: string;
+    duration: number;
+    rulesProcessed: number;
+    totalStats: {
+        matched: number;
+        sent: number;
+        skipped: number;
+        skippedByThrottle: number;
+        errors: number;
+    };
+    perRuleStats: Array<{
+        ruleId: Types.ObjectId;
+        ruleName: string;
+        matched: number;
+        sent: number;
+        skipped: number;
+        skippedByThrottle: number;
+        errors: number;
+    }>;
+}
+type EmailRuleRunLogDocument = HydratedDocument<IEmailRuleRunLog>;
+interface EmailRuleRunLogStatics {
+    getRecent(limit?: number): Promise<EmailRuleRunLogDocument[]>;
+    getByRuleId(ruleId: string | Types.ObjectId, limit?: number): Promise<EmailRuleRunLogDocument[]>;
+}
+type EmailRuleRunLogModel = Model<IEmailRuleRunLog> & EmailRuleRunLogStatics;
+declare function createEmailRuleRunLogSchema(collectionPrefix?: string): Schema<IEmailRuleRunLog, Model<IEmailRuleRunLog, any, any, any, mongoose.Document<unknown, any, IEmailRuleRunLog, any, {}> & IEmailRuleRunLog & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IEmailRuleRunLog, mongoose.Document<unknown, {}, mongoose.FlatRecord<IEmailRuleRunLog>, {}, mongoose.DefaultSchemaOptions> & mongoose.FlatRecord<IEmailRuleRunLog> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+
+interface EmailThrottleConfig {
+    _id: string;
+    maxPerUserPerDay: number;
+    maxPerUserPerWeek: number;
+    minGapDays: number;
+    throttleWindow: ThrottleWindow;
+    updatedAt: Date;
+}
+interface UpdateEmailThrottleConfigInput {
+    maxPerUserPerDay?: number;
+    maxPerUserPerWeek?: number;
+    minGapDays?: number;
+}
+
+interface IEmailThrottleConfig extends Omit<EmailThrottleConfig, '_id'> {
+}
+type EmailThrottleConfigDocument = HydratedDocument<IEmailThrottleConfig>;
+interface EmailThrottleConfigStatics {
+    getConfig(): Promise<EmailThrottleConfigDocument>;
+}
+type EmailThrottleConfigModel = Model<IEmailThrottleConfig> & EmailThrottleConfigStatics;
+declare function createEmailThrottleConfigSchema(collectionPrefix?: string): Schema<IEmailThrottleConfig, Model<IEmailThrottleConfig, any, any, any, mongoose.Document<unknown, any, IEmailThrottleConfig, any, {}> & IEmailThrottleConfig & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IEmailThrottleConfig, mongoose.Document<unknown, {}, mongoose.FlatRecord<IEmailThrottleConfig>, {}, mongoose.DefaultSchemaOptions> & mongoose.FlatRecord<IEmailThrottleConfig> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+
+declare class TemplateService {
+    private EmailTemplate;
+    private config;
+    private renderService;
+    constructor(EmailTemplate: EmailTemplateModel, config: EmailRuleEngineConfig);
+    list(filters?: {
+        category?: TemplateCategory;
+        audience?: TemplateAudience;
+        platform?: string;
+        isActive?: boolean;
+    }): Promise<EmailTemplateDocument[]>;
+    getById(id: string): Promise<EmailTemplateDocument | null>;
+    getBySlug(slug: string): Promise<EmailTemplateDocument | null>;
+    create(input: CreateEmailTemplateInput): Promise<EmailTemplateDocument>;
+    update(id: string, input: UpdateEmailTemplateInput): Promise<EmailTemplateDocument | null>;
+    delete(id: string): Promise<boolean>;
+    toggleActive(id: string): Promise<EmailTemplateDocument | null>;
+    preview(id: string, sampleData: Record<string, unknown>): Promise<{
+        html: string;
+        text: string;
+        subject: string;
+    } | null>;
+    previewRaw(subject: string, body: string, sampleData: Record<string, unknown>, textBody?: string): Promise<{
+        html: string;
+        text: string;
+        subject: string;
+    }>;
+    validate(body: string): Promise<{
+        valid: boolean;
+        errors: string[];
+        variables: string[];
+    }>;
+    sendTestEmail(id: string, testEmail: string, sampleData: Record<string, unknown>): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+
+declare class RuleService {
+    private EmailRule;
+    private EmailTemplate;
+    private EmailRuleRunLog;
+    private config;
+    constructor(EmailRule: EmailRuleModel, EmailTemplate: EmailTemplateModel, EmailRuleRunLog: EmailRuleRunLogModel, config: EmailRuleEngineConfig);
+    list(): Promise<EmailRuleDocument[]>;
+    getById(id: string): Promise<EmailRuleDocument | null>;
+    create(input: CreateEmailRuleInput): Promise<EmailRuleDocument>;
+    update(id: string, input: UpdateEmailRuleInput): Promise<EmailRuleDocument | null>;
+    delete(id: string): Promise<{
+        deleted: boolean;
+        disabled?: boolean;
+    }>;
+    toggleActive(id: string): Promise<EmailRuleDocument | null>;
+    dryRun(id: string): Promise<{
+        matchedCount: number;
+        ruleId: string;
+    }>;
+    getRunHistory(limit?: number): Promise<unknown[]>;
+}
+
+interface UserThrottle {
+    today: number;
+    thisWeek: number;
+    lastSentDate: Date | null;
+}
+declare class RuleRunnerService {
+    private EmailRule;
+    private EmailTemplate;
+    private EmailRuleSend;
+    private EmailRuleRunLog;
+    private EmailThrottleConfig;
+    private config;
+    private templateRenderer;
+    private lock;
+    private logger;
+    constructor(EmailRule: EmailRuleModel, EmailTemplate: EmailTemplateModel, EmailRuleSend: EmailRuleSendModel, EmailRuleRunLog: EmailRuleRunLogModel, EmailThrottleConfig: EmailThrottleConfigModel, config: EmailRuleEngineConfig);
+    runAllRules(triggeredBy?: RunTrigger): Promise<void>;
+    executeRule(rule: any, throttleMap: Map<string, UserThrottle>, throttleConfig: any, templateMap?: Map<string, any>): Promise<RuleRunStats>;
+    private checkThrottle;
+    private getTodayStart;
+    buildThrottleMap(recentSends: any[]): Map<string, UserThrottle>;
+}
+
+declare class AlxEmailError extends AlxError {
+    constructor(message: string, code: string);
+}
+declare class ConfigValidationError extends AlxEmailError {
+    readonly field: string;
+    constructor(message: string, field: string);
+}
+declare class TemplateNotFoundError extends AlxEmailError {
+    readonly templateId: string;
+    constructor(templateId: string);
+}
+declare class TemplateSyntaxError extends AlxEmailError {
+    readonly errors: string[];
+    constructor(message: string, errors: string[]);
+}
+declare class RuleNotFoundError extends AlxEmailError {
+    readonly ruleId: string;
+    constructor(ruleId: string);
+}
+declare class RuleTemplateIncompatibleError extends AlxEmailError {
+    readonly reason: string;
+    constructor(reason: string);
+}
+declare class LockAcquisitionError extends AlxEmailError {
+    constructor();
+}
+declare class DuplicateSlugError extends AlxEmailError {
+    readonly slug: string;
+    constructor(slug: string);
+}
+
+declare function validateConfig(raw: unknown): void;
+
+interface RenderResult {
+    html: string;
+    text: string;
+    subject: string;
+}
+interface CompiledTemplate {
+    subjectFn: HandlebarsTemplateDelegate;
+    bodyFn: HandlebarsTemplateDelegate;
+    textBodyFn?: HandlebarsTemplateDelegate;
+}
+declare class TemplateRenderService {
+    constructor();
+    renderSingle(subject: string, body: string, data: Record<string, unknown>, textBody?: string): RenderResult;
+    compileBatch(subject: string, body: string, textBody?: string): CompiledTemplate;
+    renderFromCompiled(compiled: CompiledTemplate, data: Record<string, unknown>): RenderResult;
+    renderPreview(subject: string, body: string, data: Record<string, unknown>, textBody?: string): RenderResult;
+    extractVariables(template: string): string[];
+    validateTemplate(body: string): {
+        valid: boolean;
+        errors: string[];
+    };
+}
+
+declare class RedisLock {
+    private redis;
+    private lockKey;
+    private ttlMs;
+    private logger?;
+    private lockValue;
+    constructor(redis: Redis, lockKey: string, ttlMs: number, logger?: LogAdapter | undefined);
+    acquire(): Promise<boolean>;
+    release(): Promise<void>;
+}
+
+/**
+ * Engine instance with Express routes and programmatic service access.
+ */
+interface EmailRuleEngine {
+    routes: Router;
+    runner: RuleRunnerService;
+    templateService: TemplateService;
+    ruleService: RuleService;
+    models: {
+        EmailTemplate: EmailTemplateModel;
+        EmailRule: EmailRuleModel;
+        EmailRuleSend: EmailRuleSendModel;
+        EmailRuleRunLog: EmailRuleRunLogModel;
+        EmailThrottleConfig: EmailThrottleConfigModel;
+    };
+}
+/**
+ * Creates an email rule engine instance with routes, services, and models.
+ *
+ * @param config - Engine configuration including DB, Redis, adapters, and options.
+ * @returns Engine instance with Express routes and programmatic service access.
+ * @throws {ConfigValidationError} If the provided config is invalid.
+ *
+ * @example
+ * ```typescript
+ * const engine = createEmailRuleEngine({
+ *   db: { connection: mongoose.createConnection(uri) },
+ *   redis: { connection: new Redis() },
+ *   adapters: { queryUsers, resolveData, sendEmail, selectAgent, findIdentifier },
+ * });
+ * app.use('/api/email-rules', engine.routes);
+ * ```
+ */
+declare function createEmailRuleEngine(config: EmailRuleEngineConfig): EmailRuleEngine;
+
+export { type AgentSelection, AlxEmailError, type CompiledTemplate, ConfigValidationError, type CreateEmailRuleInput, type CreateEmailTemplateInput, DuplicateSlugError, EMAIL_SEND_STATUS, EMAIL_TYPE, type EmailRule, type EmailRuleDocument, type EmailRuleEngine, type EmailRuleEngineConfig, type EmailRuleModel, type EmailRuleRunLog, type EmailRuleRunLogDocument, type EmailRuleRunLogModel, type EmailRuleRunLogStatics, type EmailRuleSend, type EmailRuleSendDocument, type EmailRuleSendModel, type EmailRuleSendStatics, type EmailRuleStatics, type EmailSendStatus, type EmailTemplate, type EmailTemplateDocument, type EmailTemplateModel, type EmailTemplateStatics, type EmailThrottleConfig, type EmailThrottleConfigDocument, type EmailThrottleConfigModel, type EmailThrottleConfigStatics, type EmailType, type IEmailRule, type IEmailRuleRunLog, type IEmailRuleSend, type IEmailTemplate, type IEmailThrottleConfig, LockAcquisitionError, type PerRuleStats, RULE_OPERATOR, RUN_TRIGGER, type RecipientIdentifier, RedisLock, type RenderResult, type RuleCondition, RuleNotFoundError, type RuleOperator, type RuleRunStats, RuleRunnerService, RuleService, type RuleTarget, RuleTemplateIncompatibleError, type RunTrigger, type SendEmailParams, TEMPLATE_AUDIENCE, TEMPLATE_CATEGORY, THROTTLE_WINDOW, type TemplateAudience, type TemplateCategory, TemplateNotFoundError, TemplateRenderService, TemplateService, TemplateSyntaxError, type ThrottleWindow, type UpdateEmailRuleInput, type UpdateEmailTemplateInput, type UpdateEmailThrottleConfigInput, createEmailRuleEngine, createEmailRuleRunLogSchema, createEmailRuleSchema, createEmailRuleSendSchema, createEmailTemplateSchema, createEmailThrottleConfigSchema, validateConfig };