@ts-cloud/core 0.2.3 → 0.2.4

package/dist/email/advanced/analytics.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Email Analytics
+ *
+ * Provides open tracking, click tracking, and email metrics
+ */
+export interface EmailAnalytics {
+    messageId: string;
+    sent: boolean;
+    sentAt?: string;
+    delivered: boolean;
+    deliveredAt?: string;
+    opened: boolean;
+    openedAt?: string;
+    openCount: number;
+    clicked: boolean;
+    clickedAt?: string;
+    clickCount: number;
+    clicks: ClickEvent[];
+    bounced: boolean;
+    bouncedAt?: string;
+    bounceType?: string;
+    complained: boolean;
+    complainedAt?: string;
+    unsubscribed: boolean;
+    unsubscribedAt?: string;
+}
+export interface ClickEvent {
+    url: string;
+    clickedAt: string;
+    userAgent?: string;
+    ipAddress?: string;
+}
+export interface EmailMetrics {
+    period: string;
+    sent: number;
+    delivered: number;
+    opened: number;
+    clicked: number;
+    bounced: number;
+    complained: number;
+    unsubscribed: number;
+    deliveryRate: number;
+    openRate: number;
+    clickRate: number;
+    bounceRate: number;
+    complaintRate: number;
+}
+/**
+ * Email Analytics Module
+ */
+export declare class EmailAnalyticsModule {
+    /**
+     * Lambda code for tracking pixel (open tracking)
+     */
+    static TrackingPixelLambdaCode: string;
+    /**
+     * Lambda code for click tracking
+     */
+    static ClickTrackingLambdaCode: string;
+    /**
+     * Lambda code for processing SES events
+     */
+    static SesEventProcessorCode: string;
+    /**
+     * Create analytics DynamoDB table
+     */
+    static createAnalyticsTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create tracking pixel Lambda
+     */
+    static createTrackingPixelLambda(config: {
+        slug: string;
+        roleArn: string;
+        analyticsTable: string;
+    }): Record<string, any>;
+    /**
+     * Create click tracking Lambda
+     */
+    static createClickTrackingLambda(config: {
+        slug: string;
+        roleArn: string;
+        analyticsTable: string;
+    }): Record<string, any>;
+    /**
+     * Create SES event processor Lambda
+     */
+    static createSesEventProcessorLambda(config: {
+        slug: string;
+        roleArn: string;
+        analyticsTable: string;
+    }): Record<string, any>;
+    /**
+     * Inject tracking into email HTML
+     */
+    static injectTracking(params: {
+        html: string;
+        messageId: string;
+        trackingDomain: string;
+    }): string;
+    /**
+     * Calculate email metrics for a period
+     */
+    static calculateMetrics(analytics: EmailAnalytics[]): EmailMetrics;
+}
+export default EmailAnalyticsModule;

package/dist/email/advanced/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Email Advanced Features
+ */
+export * from './search';
+export * from './threading';
+export * from './scheduling';
+export * from './analytics';
+export * from './templates';
+export * from './shared-mailboxes';
+export * from './rules';

package/dist/email/advanced/rules.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Email Rules and Automation
+ *
+ * Provides email filtering, routing, and automation
+ */
+export interface EmailRule {
+    id: string;
+    name: string;
+    enabled: boolean;
+    priority: number;
+    conditions: RuleCondition[];
+    conditionOperator: 'and' | 'or';
+    actions: RuleAction[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RuleCondition {
+    field: 'from' | 'to' | 'subject' | 'body' | 'headers' | 'attachments' | 'size';
+    operator: 'contains' | 'not-contains' | 'equals' | 'not-equals' | 'starts-with' | 'ends-with' | 'regex' | 'greater-than' | 'less-than';
+    value: string;
+    caseSensitive?: boolean;
+}
+export interface RuleAction {
+    type: 'move' | 'copy' | 'delete' | 'label' | 'forward' | 'reply' | 'mark-read' | 'mark-starred' | 'webhook' | 'lambda';
+    params: Record<string, any>;
+}
+export interface AutomationWorkflow {
+    id: string;
+    name: string;
+    trigger: WorkflowTrigger;
+    steps: WorkflowStep[];
+    enabled: boolean;
+}
+export interface WorkflowTrigger {
+    type: 'email-received' | 'email-sent' | 'schedule' | 'webhook';
+    conditions?: RuleCondition[];
+}
+export interface WorkflowStep {
+    id: string;
+    type: 'delay' | 'condition' | 'action' | 'loop';
+    config: Record<string, any>;
+    next?: string;
+    onTrue?: string;
+    onFalse?: string;
+}
+/**
+ * Email Rules Module
+ */
+export declare class EmailRules {
+    /**
+     * Lambda code for rule processing
+     */
+    static RuleProcessorCode: string;
+    /**
+     * Create rules DynamoDB table
+     */
+    static createRulesTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create rule processor Lambda
+     */
+    static createRuleProcessorLambda(config: {
+        slug: string;
+        roleArn: string;
+        emailBucket: string;
+        rulesTable: string;
+    }): Record<string, any>;
+    /**
+     * Built-in rule templates
+     */
+    static readonly RuleTemplates: {
+        readonly spamFilter: {
+            readonly name: "Spam Filter";
+            readonly conditions: readonly [{
+                readonly field: "subject";
+                readonly operator: "regex";
+                readonly value: "(viagra|lottery|winner|prince|inheritance)";
+                readonly caseSensitive: false;
+            }];
+            readonly conditionOperator: "or";
+            readonly actions: readonly [{
+                readonly type: "move";
+                readonly params: {
+                    readonly folder: "spam";
+                };
+            }, {
+                readonly type: "mark-read";
+                readonly params: {};
+            }];
+        };
+        readonly autoLabel: {
+            readonly name: "Auto Label Invoices";
+            readonly conditions: readonly [{
+                readonly field: "subject";
+                readonly operator: "contains";
+                readonly value: "invoice";
+                readonly caseSensitive: false;
+            }];
+            readonly conditionOperator: "and";
+            readonly actions: readonly [{
+                readonly type: "label";
+                readonly params: {
+                    readonly label: "invoices";
+                };
+            }];
+        };
+        readonly forwardUrgent: {
+            readonly name: "Forward Urgent";
+            readonly conditions: readonly [{
+                readonly field: "subject";
+                readonly operator: "contains";
+                readonly value: "urgent";
+                readonly caseSensitive: false;
+            }];
+            readonly conditionOperator: "and";
+            readonly actions: readonly [{
+                readonly type: "forward";
+                readonly params: {
+                    readonly to: "admin@example.com";
+                };
+            }, {
+                readonly type: "label";
+                readonly params: {
+                    readonly label: "urgent";
+                };
+            }];
+        };
+    };
+}
+export default EmailRules;

package/dist/email/advanced/scheduling.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Email Scheduling (Send Later)
+ *
+ * Provides scheduled email sending functionality
+ */
+export interface ScheduledEmail {
+    id: string;
+    email: {
+        from: string;
+        to: string | string[];
+        cc?: string[];
+        bcc?: string[];
+        subject: string;
+        html?: string;
+        text?: string;
+        attachments?: Array<{
+            filename: string;
+            content: string;
+            contentType?: string;
+        }>;
+    };
+    scheduledFor: string;
+    timezone?: string;
+    status: 'pending' | 'sent' | 'failed' | 'cancelled';
+    createdAt: string;
+    sentAt?: string;
+    error?: string;
+    retryCount?: number;
+}
+/**
+ * Email Scheduling Module
+ */
+export declare class EmailScheduling {
+    /**
+     * Lambda code for processing scheduled emails
+     */
+    static SchedulerLambdaCode: string;
+    /**
+     * Create scheduler Lambda function
+     */
+    static createSchedulerLambda(config: {
+        slug: string;
+        roleArn: string;
+        emailBucket: string;
+    }): Record<string, any>;
+    /**
+     * Create EventBridge rule to trigger scheduler
+     */
+    static createSchedulerRule(config: {
+        slug: string;
+        lambdaArn: string;
+        scheduleExpression?: string;
+    }): Record<string, any>;
+    /**
+     * Schedule an email (SDK helper)
+     */
+    static scheduleEmail(params: {
+        s3Client: any;
+        bucket: string;
+        email: ScheduledEmail['email'];
+        scheduledFor: Date | string;
+        timezone?: string;
+    }): Promise<ScheduledEmail>;
+    /**
+     * Cancel a scheduled email
+     */
+    static cancelScheduledEmail(params: {
+        s3Client: any;
+        bucket: string;
+        id: string;
+    }): Promise<boolean>;
+    /**
+     * List scheduled emails
+     */
+    static listScheduledEmails(params: {
+        s3Client: any;
+        bucket: string;
+        status?: ScheduledEmail['status'];
+    }): Promise<ScheduledEmail[]>;
+}
+export default EmailScheduling;

package/dist/email/advanced/search.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Email Search and Indexing
+ *
+ * Provides OpenSearch integration for email search functionality
+ */
+export interface EmailSearchConfig {
+    slug: string;
+    environment: string;
+    domainName?: string;
+    instanceType?: string;
+    instanceCount?: number;
+    ebsVolumeSize?: number;
+    masterUserName?: string;
+    masterUserPassword?: string;
+}
+export interface EmailSearchDocument {
+    messageId: string;
+    from: string;
+    fromName?: string;
+    to: string;
+    toName?: string;
+    cc?: string[];
+    subject: string;
+    body: string;
+    bodyPreview: string;
+    date: string;
+    receivedAt: string;
+    hasAttachments: boolean;
+    attachmentNames?: string[];
+    labels?: string[];
+    folder: string;
+    threadId?: string;
+    isRead: boolean;
+    isStarred?: boolean;
+    mailbox: string;
+}
+export interface SearchQuery {
+    query: string;
+    from?: string;
+    to?: string;
+    subject?: string;
+    hasAttachments?: boolean;
+    dateFrom?: string;
+    dateTo?: string;
+    folder?: string;
+    labels?: string[];
+    isRead?: boolean;
+    limit?: number;
+    offset?: number;
+    sort?: 'date' | 'relevance';
+    sortOrder?: 'asc' | 'desc';
+}
+export interface SearchResult {
+    total: number;
+    hits: Array<{
+        score: number;
+        document: EmailSearchDocument;
+        highlights?: Record<string, string[]>;
+    }>;
+}
+/**
+ * Email Search Module
+ */
+export declare class EmailSearch {
+    /**
+     * Create OpenSearch domain for email indexing
+     */
+    static createSearchDomain(config: EmailSearchConfig): Record<string, any>;
+    /**
+     * Create Lambda for indexing emails
+     */
+    static createIndexerLambda(config: {
+        slug: string;
+        roleArn: string;
+        searchDomainEndpoint: string;
+        emailBucket: string;
+    }): Record<string, any>;
+    /**
+     * Lambda code for email indexing
+     */
+    static IndexerLambdaCode: string;
+    /**
+     * Create email index mapping
+     */
+    static getIndexMapping(): Record<string, any>;
+    /**
+     * Build OpenSearch query from search parameters
+     */
+    static buildSearchQuery(params: SearchQuery): Record<string, any>;
+}
+export default EmailSearch;

package/dist/email/advanced/shared-mailboxes.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Shared Mailboxes for Teams
+ *
+ * Provides shared mailbox functionality with team access
+ */
+export interface SharedMailbox {
+    id: string;
+    address: string;
+    displayName: string;
+    description?: string;
+    members: MailboxMember[];
+    settings: MailboxSettings;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MailboxMember {
+    userId: string;
+    email: string;
+    name?: string;
+    role: 'owner' | 'admin' | 'member' | 'viewer';
+    permissions: MailboxPermissions;
+    addedAt: string;
+    addedBy: string;
+}
+export interface MailboxPermissions {
+    read: boolean;
+    send: boolean;
+    delete: boolean;
+    manage: boolean;
+    assignTo: boolean;
+}
+export interface MailboxSettings {
+    autoAssign: boolean;
+    assignmentStrategy: 'round-robin' | 'least-busy' | 'manual';
+    notifyOnNew: boolean;
+    notifyMembers: string[];
+    signature?: string;
+    autoResponder?: {
+        enabled: boolean;
+        subject: string;
+        body: string;
+    };
+}
+export interface MailboxAssignment {
+    messageId: string;
+    assignedTo: string;
+    assignedBy: string;
+    assignedAt: string;
+    status: 'open' | 'in-progress' | 'resolved' | 'closed';
+    notes?: string;
+}
+/**
+ * Shared Mailboxes Module
+ */
+export declare class SharedMailboxes {
+    /**
+     * Lambda code for shared mailbox management
+     */
+    static SharedMailboxLambdaCode: string;
+    /**
+     * Create shared mailbox DynamoDB table
+     */
+    static createMailboxTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create shared mailbox Lambda
+     */
+    static createSharedMailboxLambda(config: {
+        slug: string;
+        roleArn: string;
+        emailBucket: string;
+        mailboxTable: string;
+    }): Record<string, any>;
+    /**
+     * Default permission sets
+     */
+    static readonly PermissionSets: {
+        readonly owner: {
+            readonly read: true;
+            readonly send: true;
+            readonly delete: true;
+            readonly manage: true;
+            readonly assignTo: true;
+        };
+        readonly admin: {
+            readonly read: true;
+            readonly send: true;
+            readonly delete: true;
+            readonly manage: true;
+            readonly assignTo: true;
+        };
+        readonly member: {
+            readonly read: true;
+            readonly send: true;
+            readonly delete: false;
+            readonly manage: false;
+            readonly assignTo: true;
+        };
+        readonly viewer: {
+            readonly read: true;
+            readonly send: false;
+            readonly delete: false;
+            readonly manage: false;
+            readonly assignTo: false;
+        };
+    };
+}
+export default SharedMailboxes;

package/dist/email/advanced/templates.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Email Templates with Stacks Views
+ *
+ * Provides template management and rendering
+ */
+export interface EmailTemplate {
+    id: string;
+    name: string;
+    subject: string;
+    html: string;
+    text?: string;
+    variables: string[];
+    category?: string;
+    createdAt: string;
+    updatedAt: string;
+    version: number;
+}
+export interface TemplateRenderOptions {
+    data: Record<string, any>;
+    locale?: string;
+    timezone?: string;
+}
+/**
+ * Email Templates Module
+ */
+export declare class EmailTemplates {
+    /**
+     * Lambda code for template rendering
+     */
+    static TemplateRendererCode: string;
+    /**
+     * Built-in email templates
+     */
+    static BuiltInTemplates: {
+        welcome: {
+            id: string;
+            name: string;
+            subject: string;
+            html: string;
+            text: string;
+            variables: readonly ["appName", "userName", "verificationUrl"];
+            category: string;
+        };
+        passwordReset: {
+            id: string;
+            name: string;
+            subject: string;
+            html: string;
+            text: string;
+            variables: readonly ["appName", "userName", "resetUrl", "expiresIn"];
+            category: string;
+        };
+        notification: {
+            id: string;
+            name: string;
+            subject: string;
+            html: string;
+            text: string;
+            variables: readonly ["subject", "title", "message", "actionUrl", "actionText", "appName"];
+            category: string;
+        };
+        invoice: {
+            id: string;
+            name: string;
+            subject: string;
+            html: string;
+            variables: readonly ["invoiceNumber", "customerName", "period", "items", "total", "paymentUrl", "appName"];
+            category: string;
+        };
+    };
+    /**
+     * Create template storage bucket
+     */
+    static createTemplateBucket(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create template renderer Lambda
+     */
+    static createTemplateRendererLambda(config: {
+        slug: string;
+        roleArn: string;
+        templateBucket: string;
+    }): Record<string, any>;
+    /**
+     * Render a template with data (SDK helper)
+     */
+    static render(template: string, data: Record<string, any>): string;
+    private static getNestedValue;
+    /**
+     * Extract variables from template
+     */
+    static extractVariables(template: string): string[];
+}
+export default EmailTemplates;

package/dist/email/advanced/threading.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Email Threading and Conversation View
+ *
+ * Groups emails into conversations based on subject and references
+ */
+export interface EmailThread {
+    threadId: string;
+    subject: string;
+    participants: string[];
+    messageCount: number;
+    unreadCount: number;
+    lastMessageDate: string;
+    firstMessageDate: string;
+    messages: ThreadMessage[];
+    labels?: string[];
+    isStarred?: boolean;
+}
+export interface ThreadMessage {
+    messageId: string;
+    from: string;
+    fromName?: string;
+    to: string[];
+    cc?: string[];
+    date: string;
+    bodyPreview: string;
+    isRead: boolean;
+    hasAttachments: boolean;
+}
+/**
+ * Email Threading Module
+ */
+export declare class EmailThreading {
+    /**
+     * Lambda code for threading emails
+     */
+    static ThreadingLambdaCode: string;
+    /**
+     * Create threading Lambda function
+     */
+    static createThreadingLambda(config: {
+        slug: string;
+        roleArn: string;
+        emailBucket: string;
+    }): Record<string, any>;
+    /**
+     * Get threads for a mailbox (SDK helper)
+     */
+    static getThreads(params: {
+        s3Client: any;
+        bucket: string;
+        mailbox: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<EmailThread[]>;
+    /**
+     * Get a specific thread
+     */
+    static getThread(params: {
+        s3Client: any;
+        bucket: string;
+        mailbox: string;
+        threadId: string;
+    }): Promise<EmailThread | null>;
+}
+export default EmailThreading;