@ts-cloud/core 0.2.3 → 0.2.5

package/dist/security/secrets-manager.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Secrets Management
+ * Versioning, audit logging, and external secret manager integration
+ */
+export interface SecretVersion {
+    id: string;
+    secretId: string;
+    versionId: string;
+    versionStages: string[];
+    value?: string;
+    createdAt: Date;
+    deprecatedAt?: Date;
+}
+export interface SecretAudit {
+    id: string;
+    secretId: string;
+    action: SecretAction;
+    actor: string;
+    versionId?: string;
+    timestamp: Date;
+    ipAddress?: string;
+    userAgent?: string;
+    success: boolean;
+    error?: string;
+}
+export type SecretAction = 'CREATE' | 'READ' | 'UPDATE' | 'DELETE' | 'ROTATE' | 'RESTORE' | 'REPLICATE';
+export interface ExternalSecretManager {
+    id: string;
+    type: 'vault' | 'onepassword' | 'azure_keyvault' | 'gcp_secretmanager';
+    name: string;
+    endpoint?: string;
+    authentication: ExternalAuthConfig;
+    syncEnabled?: boolean;
+    syncInterval?: number;
+}
+export interface ExternalAuthConfig {
+    type: 'token' | 'iam' | 'certificate' | 'apikey';
+    credentials?: Record<string, string>;
+    roleArn?: string;
+    certificateArn?: string;
+}
+export interface SecretReplication {
+    id: string;
+    secretId: string;
+    sourceRegion: string;
+    replicaRegions: string[];
+    kmsKeyIds?: Record<string, string>;
+    status: 'replicating' | 'completed' | 'failed';
+}
+export interface SecretPolicy {
+    id: string;
+    secretId: string;
+    policy: PolicyDocument;
+}
+export interface PolicyDocument {
+    Version: string;
+    Statement: PolicyStatement[];
+}
+export interface PolicyStatement {
+    Effect: 'Allow' | 'Deny';
+    Principal: {
+        AWS?: string | string[];
+        Service?: string | string[];
+    };
+    Action: string | string[];
+    Resource?: string | string[];
+    Condition?: Record<string, any>;
+}
+/**
+ * Secrets manager
+ */
+export declare class SecretsManager {
+    private versions;
+    private audits;
+    private externalManagers;
+    private replications;
+    private policies;
+    private versionCounter;
+    private auditCounter;
+    private managerCounter;
+    private replicationCounter;
+    private policyCounter;
+    /**
+     * Create secret version
+     */
+    createVersion(version: Omit<SecretVersion, 'id'>): SecretVersion;
+    /**
+     * Get secret version by stage
+     */
+    getVersionByStage(secretId: string, stage: string): SecretVersion | undefined;
+    /**
+     * List versions for secret
+     */
+    listVersions(secretId: string): SecretVersion[];
+    /**
+     * Deprecate version
+     */
+    deprecateVersion(versionId: string): void;
+    /**
+     * Restore version
+     */
+    restoreVersion(versionId: string): void;
+    /**
+     * Audit secret action
+     */
+    auditAction(audit: Omit<SecretAudit, 'id' | 'timestamp'>): SecretAudit;
+    /**
+     * Get audit trail for secret
+     */
+    getAuditTrail(secretId: string, limit?: number): SecretAudit[];
+    /**
+     * Get failed access attempts
+     */
+    getFailedAccesses(secretId: string, hours?: number): SecretAudit[];
+    /**
+     * Register external secret manager
+     */
+    registerExternalManager(manager: Omit<ExternalSecretManager, 'id'>): ExternalSecretManager;
+    /**
+     * Register HashiCorp Vault
+     */
+    registerVault(options: {
+        name: string;
+        endpoint: string;
+        token?: string;
+        roleArn?: string;
+        syncEnabled?: boolean;
+    }): ExternalSecretManager;
+    /**
+     * Register 1Password
+     */
+    registerOnePassword(options: {
+        name: string;
+        endpoint?: string;
+        apiKey: string;
+        syncEnabled?: boolean;
+    }): ExternalSecretManager;
+    /**
+     * Enable secret replication
+     */
+    enableReplication(options: {
+        secretId: string;
+        sourceRegion: string;
+        replicaRegions: string[];
+        kmsKeyIds?: Record<string, string>;
+    }): SecretReplication;
+    /**
+     * Create secret policy
+     */
+    createPolicy(options: {
+        secretId: string;
+        allowedPrincipals: string[];
+        allowedActions: string[];
+    }): SecretPolicy;
+    /**
+     * Create cross-account access policy
+     */
+    createCrossAccountPolicy(options: {
+        secretId: string;
+        accountId: string;
+        roleNames: string[];
+    }): SecretPolicy;
+    /**
+     * Get version
+     */
+    getVersion(id: string): SecretVersion | undefined;
+    /**
+     * Get external manager
+     */
+    getExternalManager(id: string): ExternalSecretManager | undefined;
+    /**
+     * List external managers
+     */
+    listExternalManagers(): ExternalSecretManager[];
+    /**
+     * Get replication
+     */
+    getReplication(id: string): SecretReplication | undefined;
+    /**
+     * List replications
+     */
+    listReplications(): SecretReplication[];
+    /**
+     * Generate CloudFormation for secret
+     */
+    generateSecretCF(options: {
+        name: string;
+        description?: string;
+        kmsKeyId?: string;
+        replicaRegions?: string[];
+    }): any;
+    /**
+     * Generate CloudFormation for secret policy
+     */
+    generateSecretPolicyCF(policy: SecretPolicy): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global secrets manager instance
+ */
+export declare const secretsManager: SecretsManager;

package/dist/security/secrets-rotation.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Automated Secrets Rotation
+ * Automatic rotation for RDS credentials, API keys, and other secrets
+ */
+export interface SecretRotation {
+    id: string;
+    secretId: string;
+    secretType: SecretType;
+    rotationEnabled: boolean;
+    rotationDays: number;
+    rotationLambdaArn?: string;
+    lastRotated?: Date;
+    nextRotation?: Date;
+    versionStages?: string[];
+}
+export type SecretType = 'rds_credentials' | 'api_key' | 'oauth_token' | 'ssh_key' | 'certificate' | 'generic';
+export interface RotationConfig {
+    automaticallyAfterDays: number;
+    rotationLambda?: RotationLambda;
+    requireMasterPassword?: boolean;
+    excludeCharacters?: string;
+    passwordLength?: number;
+}
+export interface RotationLambda {
+    functionArn: string;
+    functionName: string;
+    runtime: string;
+    handler: string;
+}
+export interface RotationSchedule {
+    id: string;
+    name: string;
+    secrets: string[];
+    schedule: string;
+    enabled: boolean;
+    lastRun?: Date;
+    nextRun?: Date;
+}
+export interface RotationResult {
+    success: boolean;
+    secretId: string;
+    oldVersion: string;
+    newVersion: string;
+    rotatedAt: Date;
+    error?: string;
+}
+export interface RDSRotationConfig {
+    secretArn: string;
+    databaseIdentifier: string;
+    engine: 'postgres' | 'mysql' | 'sqlserver' | 'oracle';
+    masterSecretArn?: string;
+    superuserSecretArn?: string;
+}
+/**
+ * Secrets rotation manager
+ */
+export declare class SecretsRotationManager {
+    private rotations;
+    private schedules;
+    private rotationCounter;
+    private scheduleCounter;
+    /**
+     * Create secret rotation
+     */
+    createRotation(rotation: Omit<SecretRotation, 'id'>): SecretRotation;
+    /**
+     * Enable RDS credentials rotation
+     */
+    enableRDSRotation(options: {
+        secretId: string;
+        databaseIdentifier: string;
+        engine: 'postgres' | 'mysql' | 'sqlserver' | 'oracle';
+        rotationDays?: number;
+        masterSecretArn?: string;
+    }): SecretRotation;
+    /**
+     * Enable API key rotation
+     */
+    enableAPIKeyRotation(options: {
+        secretId: string;
+        rotationDays?: number;
+        rotationLambdaArn?: string;
+    }): SecretRotation;
+    /**
+     * Enable OAuth token rotation
+     */
+    enableOAuthRotation(options: {
+        secretId: string;
+        rotationDays?: number;
+        rotationLambdaArn: string;
+    }): SecretRotation;
+    /**
+     * Enable SSH key rotation
+     */
+    enableSSHKeyRotation(options: {
+        secretId: string;
+        rotationDays?: number;
+        rotationLambdaArn: string;
+    }): SecretRotation;
+    /**
+     * Create rotation schedule
+     */
+    createSchedule(schedule: Omit<RotationSchedule, 'id'>): RotationSchedule;
+    /**
+     * Execute rotation
+     */
+    executeRotation(rotationId: string): Promise<RotationResult>;
+    /**
+     * Check if rotation needed
+     */
+    needsRotation(rotationId: string): boolean;
+    /**
+     * Get secrets needing rotation
+     */
+    getSecretsNeedingRotation(): SecretRotation[];
+    /**
+     * Generate RDS rotation Lambda ARN
+     */
+    private generateRDSRotationLambdaArn;
+    /**
+     * Get rotation
+     */
+    getRotation(id: string): SecretRotation | undefined;
+    /**
+     * List rotations
+     */
+    listRotations(): SecretRotation[];
+    /**
+     * Get schedule
+     */
+    getSchedule(id: string): RotationSchedule | undefined;
+    /**
+     * List schedules
+     */
+    listSchedules(): RotationSchedule[];
+    /**
+     * Generate CloudFormation for rotation
+     */
+    generateRotationCF(rotation: SecretRotation): any;
+    /**
+     * Generate CloudFormation for rotation Lambda
+     */
+    generateRotationLambdaCF(options: {
+        functionName: string;
+        secretType: SecretType;
+        vpcConfig?: {
+            subnetIds: string[];
+            securityGroupIds: string[];
+        };
+    }): any;
+    /**
+     * Generate CloudFormation for rotation Lambda role
+     */
+    generateRotationLambdaRoleCF(): any;
+    /**
+     * Generate EventBridge rule for rotation schedule
+     */
+    generateRotationScheduleCF(schedule: RotationSchedule): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global secrets rotation manager instance
+ */
+export declare const secretsRotationManager: SecretsRotationManager;

package/dist/security/security.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sms/advanced/ab-testing.d.ts

@@ -0,0 +1,74 @@
+/**
+ * A/B Testing for SMS Content
+ *
+ * Provides A/B testing capabilities for SMS campaigns
+ */
+export interface AbTest {
+    id: string;
+    name: string;
+    status: 'draft' | 'running' | 'completed' | 'cancelled';
+    variants: AbVariant[];
+    trafficSplit: number[];
+    winningCriteria: 'delivery_rate' | 'click_rate' | 'reply_rate' | 'conversion_rate';
+    sampleSize: number;
+    currentSample: number;
+    winner?: string;
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+}
+export interface AbVariant {
+    id: string;
+    name: string;
+    message: string;
+    stats: VariantStats;
+}
+export interface VariantStats {
+    sent: number;
+    delivered: number;
+    clicked: number;
+    replied: number;
+    converted: number;
+    deliveryRate: number;
+    clickRate: number;
+    replyRate: number;
+    conversionRate: number;
+}
+/**
+ * A/B Testing Module
+ */
+export declare class AbTesting {
+    /**
+     * Lambda code for A/B test management
+     */
+    static AbTestManagerCode: string;
+    /**
+     * Create A/B tests DynamoDB table
+     */
+    static createAbTestsTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create A/B test manager Lambda
+     */
+    static createAbTestManagerLambda(config: {
+        slug: string;
+        roleArn: string;
+        abTestsTable: string;
+    }): Record<string, any>;
+    /**
+     * Select variant for a recipient
+     */
+    static selectVariant(test: AbTest, recipientId: string): AbVariant;
+    /**
+     * Determine winner based on criteria
+     */
+    static determineWinner(test: AbTest): AbVariant | null;
+    /**
+     * Calculate statistical significance
+     */
+    static calculateSignificance(variantA: AbVariant, variantB: AbVariant, criteria: string): number;
+    private static getMetricValue;
+    private static hashString;
+}
+export default AbTesting;

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

@@ -0,0 +1,75 @@
+/**
+ * SMS Analytics
+ *
+ * Provides delivery rates, engagement metrics, and reporting
+ */
+export interface SmsMetrics {
+    period: string;
+    sent: number;
+    delivered: number;
+    failed: number;
+    pending: number;
+    optedOut: number;
+    deliveryRate: number;
+    failureRate: number;
+    averageDeliveryTime: number;
+    cost: number;
+}
+export interface SmsEngagement {
+    messageId: string;
+    delivered: boolean;
+    deliveredAt?: string;
+    clicked?: boolean;
+    clickedAt?: string;
+    replied?: boolean;
+    repliedAt?: string;
+    replyContent?: string;
+    optedOut?: boolean;
+    optedOutAt?: string;
+}
+export interface DeliveryReport {
+    messageId: string;
+    to: string;
+    status: 'PENDING' | 'SUCCESSFUL' | 'FAILED' | 'UNKNOWN';
+    statusCode?: string;
+    statusMessage?: string;
+    carrier?: string;
+    countryCode?: string;
+    priceInMillicents?: number;
+    timestamp: string;
+}
+/**
+ * SMS Analytics Module
+ */
+export declare class SmsAnalytics {
+    /**
+     * Lambda code for analytics aggregation
+     */
+    static AnalyticsAggregatorCode: string;
+    /**
+     * Lambda code for real-time delivery tracking
+     */
+    static DeliveryTrackerCode: string;
+    /**
+     * Create analytics DynamoDB table
+     */
+    static createAnalyticsTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create delivery reports table
+     */
+    static createDeliveryReportsTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create analytics aggregator Lambda
+     */
+    static createAnalyticsAggregatorLambda(config: {
+        slug: string;
+        roleArn: string;
+        messageLogTable: string;
+        analyticsTable: string;
+    }): Record<string, any>;
+}
+export default SmsAnalytics;

package/dist/sms/advanced/campaigns.d.ts

@@ -0,0 +1,96 @@
+/**
+ * SMS Campaigns and Scheduling
+ *
+ * Provides campaign management and scheduled SMS sending
+ */
+export interface SmsCampaign {
+    id: string;
+    name: string;
+    description?: string;
+    status: 'draft' | 'scheduled' | 'running' | 'paused' | 'completed' | 'cancelled';
+    message: {
+        body: string;
+        template?: string;
+        variables?: string[];
+    };
+    audience: CampaignAudience;
+    schedule: CampaignSchedule;
+    settings: CampaignSettings;
+    stats: CampaignStats;
+    createdAt: string;
+    updatedAt: string;
+    startedAt?: string;
+    completedAt?: string;
+}
+export interface CampaignAudience {
+    type: 'list' | 'segment' | 'all';
+    listId?: string;
+    segmentId?: string;
+    filters?: AudienceFilter[];
+    estimatedSize?: number;
+}
+export interface AudienceFilter {
+    field: string;
+    operator: 'equals' | 'not-equals' | 'contains' | 'greater-than' | 'less-than';
+    value: string;
+}
+export interface CampaignSchedule {
+    type: 'immediate' | 'scheduled' | 'recurring';
+    scheduledFor?: string;
+    timezone?: string;
+    recurrence?: {
+        frequency: 'daily' | 'weekly' | 'monthly';
+        interval: number;
+        endDate?: string;
+        maxOccurrences?: number;
+    };
+}
+export interface CampaignSettings {
+    messageType: 'TRANSACTIONAL' | 'PROMOTIONAL';
+    senderId?: string;
+    originationNumber?: string;
+    throttleRate?: number;
+    quietHours?: {
+        start: string;
+        end: string;
+        timezone: string;
+    };
+    optOutHandling: boolean;
+}
+export interface CampaignStats {
+    totalRecipients: number;
+    sent: number;
+    delivered: number;
+    failed: number;
+    optedOut: number;
+    deliveryRate: number;
+    cost: number;
+}
+/**
+ * SMS Campaigns Module
+ */
+export declare class SmsCampaigns {
+    /**
+     * Lambda code for campaign management
+     */
+    static CampaignManagerCode: string;
+    /**
+     * Lambda code for campaign execution
+     */
+    static CampaignExecutorCode: string;
+    /**
+     * Create campaigns DynamoDB table
+     */
+    static createCampaignsTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create campaign manager Lambda
+     */
+    static createCampaignManagerLambda(config: {
+        slug: string;
+        roleArn: string;
+        campaignsTable: string;
+    }): Record<string, any>;
+}
+export default SmsCampaigns;

package/dist/sms/advanced/chatbot.d.ts

@@ -0,0 +1,67 @@
+/**
+ * SMS Chatbot Integration
+ *
+ * Provides conversational SMS with AI/rule-based responses
+ */
+export interface ChatbotConfig {
+    enabled: boolean;
+    provider: 'rules' | 'bedrock' | 'openai' | 'custom';
+    welcomeMessage?: string;
+    fallbackMessage?: string;
+    sessionTimeout?: number;
+    maxTurns?: number;
+}
+export interface ChatSession {
+    sessionId: string;
+    phoneNumber: string;
+    startedAt: string;
+    lastMessageAt: string;
+    turnCount: number;
+    context: Record<string, any>;
+    status: 'active' | 'ended' | 'timeout';
+}
+export interface ChatRule {
+    id: string;
+    priority: number;
+    patterns: string[];
+    response: string;
+    action?: 'respond' | 'transfer' | 'end' | 'webhook';
+    actionParams?: Record<string, any>;
+}
+/**
+ * SMS Chatbot Module
+ */
+export declare class SmsChatbot {
+    /**
+     * Lambda code for chatbot processing
+     */
+    static ChatbotProcessorCode: string;
+    /**
+     * Create sessions DynamoDB table
+     */
+    static createSessionsTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create chatbot rules table
+     */
+    static createRulesTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create chatbot processor Lambda
+     */
+    static createChatbotProcessorLambda(config: {
+        slug: string;
+        roleArn: string;
+        sessionsTable: string;
+        rulesTable: string;
+        chatbotConfig: ChatbotConfig;
+        originationNumber?: string;
+    }): Record<string, any>;
+    /**
+     * Built-in chatbot rules
+     */
+    static readonly DefaultRules: ChatRule[];
+}
+export default SmsChatbot;

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

@@ -0,0 +1,9 @@
+/**
+ * SMS Advanced Features
+ */
+export * from './campaigns';
+export * from './analytics';
+export * from './mms';
+export * from './chatbot';
+export * from './link-tracking';
+export * from './ab-testing';