@astralibx/email-rule-engine 12.10.1 → 14.0.0

package/dist/index.d.mts

@@ -1,255 +1,12 @@
-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, RedisLock } from '@astralibx/core';
-import { Router } from 'express';
+import { RuleEngineConfig, RuleEngine } from '@astralibx/rule-engine';
+export * from '@astralibx/rule-engine';
 
-type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'objectId' | 'array' | 'object';
-interface FieldDefinition {
-    name: string;
-    type: FieldType;
-    label?: string;
-    description?: string;
-    enumValues?: string[];
-    fields?: FieldDefinition[];
-}
-interface JoinDefinition {
-    from: string;
-    localField: string;
-    foreignField: string;
-    as: string;
-}
-interface CollectionSchema {
-    name: string;
-    label?: string;
-    description?: string;
-    identifierField?: string;
-    fields: FieldDefinition[];
-    joins?: JoinDefinition[];
-}
-interface FlattenedField {
-    path: string;
-    type: FieldType;
-    label?: string;
-    description?: string;
-    enumValues?: string[];
-    isArray?: boolean;
-}
+declare function renderMjml(body: string): string;
+declare function htmlToPlainText(html: string): string;
 
-declare const FIELD_TYPE: {
-    readonly String: "string";
-    readonly Number: "number";
-    readonly Boolean: "boolean";
-    readonly Date: "date";
-    readonly ObjectId: "objectId";
-    readonly Array: "array";
-    readonly Object: "object";
-};
+declare function registerEmailHelpers(): void;
 
-declare const TYPE_OPERATORS: Record<FieldType, string[]>;
-
-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];
-declare const TARGET_MODE: {
-    readonly Query: "query";
-    readonly List: "list";
-};
-type TargetMode = (typeof TARGET_MODE)[keyof typeof TARGET_MODE];
-declare const RUN_LOG_STATUS: {
-    readonly Completed: "completed";
-    readonly Cancelled: "cancelled";
-    readonly Failed: "failed";
-};
-type RunLogStatus = (typeof RUN_LOG_STATUS)[keyof typeof RUN_LOG_STATUS];
-
-interface RuleCondition {
-    field: string;
-    operator: RuleOperator;
-    value: unknown;
-}
-interface RuleRunStats {
-    matched: number;
-    sent: number;
-    skipped: number;
-    skippedByThrottle: number;
-    errorCount: number;
-}
-interface QueryTarget {
-    mode: 'query';
-    role: string;
-    platform: string;
-    conditions: RuleCondition[];
-    collectionName?: string;
-}
-interface ListTarget {
-    mode: 'list';
-    identifiers: string[];
-}
-type RuleTarget = QueryTarget | ListTarget;
-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;
-    validFrom?: Date;
-    validTill?: Date;
-    bypassThrottle: boolean;
-    throttleOverride?: {
-        maxPerUserPerDay?: number;
-        maxPerUserPerWeek?: number;
-        minGapDays?: number;
-    };
-    emailType: EmailType;
-    schedule?: {
-        enabled: boolean;
-        cron: string;
-        timezone?: string;
-    };
-    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;
-    validFrom?: Date;
-    validTill?: Date;
-    bypassThrottle?: boolean;
-    throttleOverride?: {
-        maxPerUserPerDay?: number;
-        maxPerUserPerWeek?: number;
-        minGapDays?: number;
-    };
-    emailType?: EmailType;
-    schedule?: {
-        enabled: boolean;
-        cron: string;
-        timezone?: string;
-    };
-}
-interface UpdateEmailRuleInput {
-    name?: string;
-    description?: string;
-    isActive?: boolean;
-    sortOrder?: number;
-    target?: RuleTarget;
-    templateId?: string;
-    sendOnce?: boolean;
-    resendAfterDays?: number;
-    cooldownDays?: number;
-    autoApprove?: boolean;
-    maxPerRun?: number;
-    validFrom?: Date;
-    validTill?: Date;
-    bypassThrottle?: boolean;
-    throttleOverride?: {
-        maxPerUserPerDay?: number;
-        maxPerUserPerWeek?: number;
-        minGapDays?: number;
-    };
-    emailType?: EmailType;
-    schedule?: {
-        enabled: boolean;
-        cron: string;
-        timezone?: string;
-    };
-}
-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 {
+interface EmailSendParams {
     identifierId: string;
     contactId: string;
     accountId: string;
@@ -264,621 +21,16 @@ interface SendEmailParams {
         contentType: string;
     }>;
 }
-interface AgentSelection {
-    accountId: string;
-    email: string;
-    metadata: Record<string, unknown>;
-}
-interface BeforeSendParams {
-    htmlBody: string;
-    textBody: string;
-    subject: string;
-    account: {
-        id: string;
-        email: string;
-        metadata: Record<string, unknown>;
-    };
-    user: {
-        id: string;
-        email: string;
-        name: string;
-    };
-    context: {
-        ruleId: string;
-        templateId: string;
-        runId: string;
-    };
-}
-interface BeforeSendResult {
-    htmlBody: string;
-    textBody: string;
-    subject: string;
-}
-interface RecipientIdentifier {
-    id: string;
-    contactId: string;
-}
-interface RunProgress {
-    rulesTotal: number;
-    rulesCompleted: number;
-    sent: number;
-    failed: number;
-    skipped: number;
-    invalid: number;
-}
-type RunStatus = 'running' | 'completed' | 'cancelled' | 'failed';
-interface RunStatusResponse {
-    runId: string;
-    status: RunStatus;
-    currentRule: string;
-    progress: RunProgress;
-    startedAt: string;
-    elapsed: number;
-}
-interface EmailRuleEngineConfig {
-    db: {
-        connection: Connection;
-        collectionPrefix?: string;
-    };
-    redis: {
-        connection: Redis;
-        keyPrefix?: string;
-    };
-    collections?: CollectionSchema[];
-    adapters: {
-        queryUsers: (target: RuleTarget, limit: number, context?: {
-            collectionSchema?: CollectionSchema;
-        }) => 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>;
+interface EmailRuleEngineConfig extends Omit<RuleEngineConfig, 'adapters'> {
+    adapters: Omit<RuleEngineConfig['adapters'], 'send' | 'sendTest'> & {
+        sendEmail: (params: EmailSendParams) => Promise<void>;
         sendTestEmail?: (to: string, subject: string, html: string, text: string, attachments?: Array<{
             filename: string;
             url: string;
             contentType: 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;
-            runId: string;
-        }) => void;
-        onRuleStart?: (info: {
-            ruleId: string;
-            ruleName: string;
-            matchedCount: number;
-            templateId: string;
-            runId: string;
-        }) => void;
-        onSend?: (info: {
-            ruleId: string;
-            ruleName: string;
-            email: string;
-            status: 'sent' | 'error' | 'skipped' | 'invalid' | 'throttled';
-            accountId: string;
-            templateId: string;
-            runId: string;
-            subjectIndex: number;
-            bodyIndex: number;
-            preheaderIndex?: number;
-            failureReason?: string;
-        }) => void;
-        onRuleComplete?: (info: {
-            ruleId: string;
-            ruleName: string;
-            stats: RuleRunStats;
-            templateId: string;
-            runId: string;
-        }) => void;
-        onRunComplete?: (info: {
-            duration: number;
-            totalStats: RuleRunStats;
-            perRuleStats: PerRuleStats[];
-            runId: string;
-        }) => void;
-        beforeSend?: (params: BeforeSendParams) => Promise<BeforeSendResult>;
-    };
-}
-
-interface EmailAttachment {
-    filename: string;
-    url: string;
-    contentType: string;
-}
-interface EmailTemplate {
-    _id: string;
-    name: string;
-    slug: string;
-    description?: string;
-    category: string;
-    audience: string;
-    platform: string;
-    textBody?: string;
-    subjects: string[];
-    bodies: string[];
-    preheaders?: string[];
-    fields?: Record<string, string>;
-    variables: string[];
-    version: number;
-    isActive: boolean;
-    attachments?: EmailAttachment[];
-    createdAt: Date;
-    updatedAt: Date;
-}
-interface CreateEmailTemplateInput {
-    name: string;
-    slug: string;
-    description?: string;
-    category: string;
-    audience: string;
-    platform: string;
-    textBody?: string;
-    subjects: string[];
-    bodies: string[];
-    preheaders?: string[];
-    fields?: Record<string, string>;
-    variables?: string[];
-    attachments?: EmailAttachment[];
-}
-interface UpdateEmailTemplateInput {
-    name?: string;
-    description?: string;
-    category?: string;
-    audience?: string;
-    platform?: string;
-    textBody?: string;
-    subjects?: string[];
-    bodies?: string[];
-    preheaders?: string[];
-    fields?: Record<string, string>;
-    variables?: string[];
-    attachments?: EmailAttachment[];
-    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: string): Promise<EmailTemplateDocument[]>;
-    findByAudience(audience: string): 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: string;
-    emailIdentifierId?: string;
-    messageId?: string;
-    sentAt: Date;
-    status?: string;
-    accountId?: string;
-    senderName?: string;
-    subject?: string;
-    subjectIndex?: number;
-    bodyIndex?: number;
-    preheaderIndex?: number;
-    failureReason?: string;
-}
-type EmailRuleSendDocument = HydratedDocument<IEmailRuleSend>;
-interface EmailRuleSendStatics {
-    findLatestForUser(ruleId: string | Types.ObjectId, userId: string): Promise<EmailRuleSendDocument | null>;
-    findRecentByUserIds(userIds: string[], sinceDays: number): Promise<EmailRuleSendDocument[]>;
-    logSend(ruleId: string | Types.ObjectId, userId: string, emailIdentifierId?: string, messageId?: string, extra?: {
-        status?: string;
-        accountId?: string;
-        senderName?: string;
-        subject?: string;
-        subjectIndex?: number;
-        bodyIndex?: number;
-        preheaderIndex?: number;
-        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 {
-    runId?: string;
-    runAt: Date;
-    triggeredBy: string;
-    duration: number;
-    rulesProcessed: number;
-    status?: string;
-    totalStats: {
-        matched: number;
-        sent: number;
-        skipped: number;
-        skippedByThrottle: number;
-        errorCount: number;
-    };
-    perRuleStats: Array<{
-        ruleId: Types.ObjectId;
-        ruleName: string;
-        matched: number;
-        sent: number;
-        skipped: number;
-        skippedByThrottle: number;
-        errorCount: 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 EmailRule?;
-    private renderService;
-    constructor(EmailTemplate: EmailTemplateModel, config: EmailRuleEngineConfig, EmailRule?: EmailRuleModel | undefined);
-    list(filters?: {
-        category?: string;
-        audience?: string;
-        platform?: string;
-        isActive?: boolean;
-        page?: number;
-        limit?: number;
-    }): Promise<{
-        templates: EmailTemplateDocument[];
-        total: number;
-    }>;
-    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>;
-    private _buildSampleData;
-    preview(id: string, sampleData: Record<string, unknown>): Promise<{
-        html: string;
-        text: string;
-        subject: string;
-    } | null>;
-    previewRaw(subject: string, body: string, sampleData: Record<string, unknown>, variables?: string[], textBody?: string): Promise<{
-        html: string;
-        text: string;
-        subject: string;
-    }>;
-    validate(body: string): Promise<{
-        valid: boolean;
-        errors: string[];
-        variables: string[];
-    }>;
-    clone(sourceId: string, newName?: string): Promise<any>;
-    sendTestEmail(id: string, testEmail: string, sampleData: Record<string, unknown>): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    previewWithRecipient(templateId: string, recipientData: Record<string, unknown>): Promise<{
-        html: string;
-        text: string;
-        subject: string;
-    } | null>;
-}
-
-declare class RuleService {
-    private EmailRule;
-    private EmailTemplate;
-    private EmailRuleRunLog;
-    private config;
-    constructor(EmailRule: EmailRuleModel, EmailTemplate: EmailTemplateModel, EmailRuleRunLog: EmailRuleRunLogModel, config: EmailRuleEngineConfig);
-    list(opts?: {
-        page?: number;
-        limit?: number;
-    }): Promise<{
-        rules: EmailRuleDocument[];
-        total: number;
-    }>;
-    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;
-        effectiveLimit: number;
-        willProcess: number;
-        ruleId: string;
-        sample: Array<{
-            email: string;
-            name?: string;
-            [key: string]: unknown;
-        }>;
-    }>;
-    clone(sourceId: string, newName?: string): Promise<any>;
-    getRunHistory(limit?: number, opts?: {
-        page?: number;
-        from?: string;
-        to?: string;
-    }): Promise<unknown[]>;
-    getRunHistoryCount(opts?: {
-        from?: string;
-        to?: string;
-    }): Promise<number>;
-}
-
-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;
-    private redis;
-    private keyPrefix;
-    constructor(EmailRule: EmailRuleModel, EmailTemplate: EmailTemplateModel, EmailRuleSend: EmailRuleSendModel, EmailRuleRunLog: EmailRuleRunLogModel, EmailThrottleConfig: EmailThrottleConfigModel, config: EmailRuleEngineConfig);
-    runAllRules(triggeredBy?: RunTrigger, runId?: string): Promise<{
-        runId: string;
-    }>;
-    executeRule(rule: any, throttleMap: Map<string, UserThrottle>, throttleConfig: any, templateMap?: Map<string, any>, runId?: string): Promise<RuleRunStats>;
-    private emitSendEvent;
-    private processSingleUser;
-    private resolveIdentifiers;
-    private buildSendMap;
-    private compileTemplateVariants;
-    private checkCancelled;
-    private applySendDelay;
-    private finalizeRuleStats;
-    private executeListMode;
-    private executeQueryMode;
-    private checkThrottle;
-    private getTodayStart;
-    private updateRunProgress;
-    private updateRunSendProgress;
-    getStatus(runId: string): Promise<RunStatusResponse | null>;
-    cancel(runId: string): Promise<{
-        ok: boolean;
-    }>;
-    trigger(triggeredBy?: RunTrigger): {
-        runId: string;
-        started: boolean;
-    };
-    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 ConditionValidationError {
-    index: number;
-    field: string;
-    message: string;
-}
-declare function validateConditions(conditions: RuleCondition[], collectionName: string | undefined, collections: CollectionSchema[]): ConditionValidationError[];
-
-declare function flattenFields(fields: FieldDefinition[], prefix?: string, parentIsArray?: boolean): FlattenedField[];
-
-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;
-    compileBatchVariants(subjects: string[], bodies: string[], textBody?: string, preheaders?: string[]): {
-        subjectFns: HandlebarsTemplateDelegate[];
-        bodyFns: HandlebarsTemplateDelegate[];
-        textBodyFn?: HandlebarsTemplateDelegate;
-        preheaderFns?: HandlebarsTemplateDelegate[];
-    };
-    renderFromCompiled(compiled: CompiledTemplate, data: Record<string, unknown>): RenderResult;
-    renderPreview(subject: string, body: string, data: Record<string, unknown>, textBody?: string): RenderResult;
-    htmlToText(html: string): string;
-    extractVariables(template: string): string[];
-    validateTemplate(body: string): {
-        valid: boolean;
-        errors: string[];
-    };
-}
-
-declare class SchedulerService {
-    private queue;
-    private worker?;
-    private keyPrefix;
-    constructor(connection: Redis, keyPrefix?: string);
-    syncRule(rule: {
-        _id: any;
-        schedule?: {
-            enabled: boolean;
-            cron: string;
-            timezone?: string;
-        };
-    }): Promise<void>;
-    removeRule(ruleId: string): Promise<void>;
-    startWorker(runFn: (triggeredBy: string) => Promise<any>): void;
-    stopWorker(): Promise<void>;
-    getScheduledJobs(): Promise<Array<{
-        ruleId: string;
-        cron: string;
-        next: number | null;
-    }>>;
-}
-
-/**
- * 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;
+declare function createEmailRuleEngine(config: EmailRuleEngineConfig): RuleEngine;
 
-export { type AgentSelection, AlxEmailError, type BeforeSendParams, type BeforeSendResult, type CollectionSchema, type CompiledTemplate, type ConditionValidationError, ConfigValidationError, type CreateEmailRuleInput, type CreateEmailTemplateInput, DuplicateSlugError, EMAIL_SEND_STATUS, EMAIL_TYPE, type EmailAttachment, 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, FIELD_TYPE, type FieldDefinition, type FieldType, type FlattenedField, type IEmailRule, type IEmailRuleRunLog, type IEmailRuleSend, type IEmailTemplate, type IEmailThrottleConfig, type JoinDefinition, type ListTarget, LockAcquisitionError, type PerRuleStats, type QueryTarget, RULE_OPERATOR, RUN_LOG_STATUS, RUN_TRIGGER, type RecipientIdentifier, type RenderResult, type RuleCondition, RuleNotFoundError, type RuleOperator, type RuleRunStats, RuleRunnerService, RuleService, type RuleTarget, RuleTemplateIncompatibleError, type RunLogStatus, type RunTrigger, SchedulerService, type SendEmailParams, TARGET_MODE, TEMPLATE_AUDIENCE, TEMPLATE_CATEGORY, THROTTLE_WINDOW, TYPE_OPERATORS, type TargetMode, type TemplateAudience, type TemplateCategory, TemplateNotFoundError, TemplateRenderService, TemplateService, TemplateSyntaxError, type ThrottleWindow, type UpdateEmailRuleInput, type UpdateEmailTemplateInput, type UpdateEmailThrottleConfigInput, createEmailRuleEngine, createEmailRuleRunLogSchema, createEmailRuleSchema, createEmailRuleSendSchema, createEmailTemplateSchema, createEmailThrottleConfigSchema, flattenFields, validateConditions, validateConfig };
+export { type EmailRuleEngineConfig, type EmailSendParams, createEmailRuleEngine, htmlToPlainText, registerEmailHelpers, renderMjml };