@ts-cloud/core 0.2.3 → 0.2.5

package/dist/observability/xray.d.ts

@@ -0,0 +1,193 @@
+/**
+ * AWS X-Ray Integration
+ * Distributed tracing for microservices and serverless applications
+ */
+export interface XRayConfig {
+    id: string;
+    name: string;
+    serviceName: string;
+    samplingRate: number;
+    enableActiveTracing: boolean;
+    segmentDocuments?: SegmentDocument[];
+}
+export interface SegmentDocument {
+    id: string;
+    name: string;
+    startTime: number;
+    endTime?: number;
+    subsegments?: SubSegment[];
+    annotations?: Record<string, string | number | boolean>;
+    metadata?: Record<string, any>;
+    http?: HttpData;
+    aws?: AWSData;
+    error?: boolean;
+    fault?: boolean;
+    throttle?: boolean;
+}
+export interface SubSegment {
+    id: string;
+    name: string;
+    startTime: number;
+    endTime?: number;
+    namespace?: 'aws' | 'remote';
+    http?: HttpData;
+    sql?: SqlData;
+    annotations?: Record<string, string | number | boolean>;
+    metadata?: Record<string, any>;
+}
+export interface HttpData {
+    request?: {
+        method?: string;
+        url?: string;
+        userAgent?: string;
+        clientIp?: string;
+    };
+    response?: {
+        status?: number;
+        contentLength?: number;
+    };
+}
+export interface AWSData {
+    accountId?: string;
+    operation?: string;
+    region?: string;
+    requestId?: string;
+    queueUrl?: string;
+    tableName?: string;
+}
+export interface SqlData {
+    url?: string;
+    preparation?: 'statement' | 'call';
+    databaseType?: string;
+    databaseVersion?: string;
+    driverVersion?: string;
+    user?: string;
+    sanitizedQuery?: string;
+}
+export interface SamplingRule {
+    id: string;
+    ruleName: string;
+    priority: number;
+    fixedRate: number;
+    reservoirSize: number;
+    serviceName: string;
+    serviceType: string;
+    host: string;
+    httpMethod: string;
+    urlPath: string;
+    version: number;
+}
+/**
+ * X-Ray manager
+ */
+export declare class XRayManager {
+    private configs;
+    private samplingRules;
+    private configCounter;
+    private ruleCounter;
+    /**
+     * Create X-Ray configuration
+     */
+    createConfig(config: Omit<XRayConfig, 'id'>): XRayConfig;
+    /**
+     * Create Lambda X-Ray configuration
+     */
+    createLambdaConfig(options: {
+        functionName: string;
+        samplingRate?: number;
+    }): XRayConfig;
+    /**
+     * Create ECS X-Ray configuration
+     */
+    createECSConfig(options: {
+        serviceName: string;
+        clusterName: string;
+        samplingRate?: number;
+    }): XRayConfig;
+    /**
+     * Create API Gateway X-Ray configuration
+     */
+    createAPIGatewayConfig(options: {
+        apiName: string;
+        stage: string;
+        samplingRate?: number;
+    }): XRayConfig;
+    /**
+     * Create sampling rule
+     */
+    createSamplingRule(rule: Omit<SamplingRule, 'id'>): SamplingRule;
+    /**
+     * Create high-priority sampling rule (always trace)
+     */
+    createHighPrioritySamplingRule(options: {
+        ruleName: string;
+        serviceName: string;
+        urlPath: string;
+    }): SamplingRule;
+    /**
+     * Create error sampling rule (trace all errors)
+     */
+    createErrorSamplingRule(serviceName: string): SamplingRule;
+    /**
+     * Create default sampling rule
+     */
+    createDefaultSamplingRule(serviceName: string, samplingRate?: number): SamplingRule;
+    /**
+     * Get config
+     */
+    getConfig(id: string): XRayConfig | undefined;
+    /**
+     * List configs
+     */
+    listConfigs(): XRayConfig[];
+    /**
+     * Get sampling rule
+     */
+    getSamplingRule(id: string): SamplingRule | undefined;
+    /**
+     * List sampling rules
+     */
+    listSamplingRules(): SamplingRule[];
+    /**
+     * Generate CloudFormation for Lambda X-Ray
+     */
+    generateLambdaXRayCF(config: XRayConfig): any;
+    /**
+     * Generate CloudFormation for API Gateway X-Ray
+     */
+    generateAPIGatewayXRayCF(config: XRayConfig): any;
+    /**
+     * Generate ECS task definition with X-Ray sidecar
+     */
+    generateECSXRaySidecarCF(): any;
+    /**
+     * Generate sampling rules CloudFormation
+     */
+    generateSamplingRuleCF(rule: SamplingRule): any;
+    /**
+     * Create a distributed trace
+     */
+    createTrace(traceId: string, spans: Array<{
+        spanId: string;
+        name: string;
+        duration: number;
+        tags: Record<string, any>;
+    }>): {
+        id: string;
+        traceId: string;
+        spans: Array<{
+            spanId: string;
+            name: string;
+            duration: number;
+            tags: Record<string, any>;
+        }>;
+    };
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global X-Ray manager instance
+ */
+export declare const xrayManager: XRayManager;

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

@@ -0,0 +1,83 @@
+/**
+ * Call Analytics and Reporting
+ *
+ * Provides call metrics, reporting, and insights
+ */
+export interface CallMetrics {
+    period: string;
+    totalCalls: number;
+    answeredCalls: number;
+    missedCalls: number;
+    abandonedCalls: number;
+    voicemails: number;
+    averageWaitTime: number;
+    averageHandleTime: number;
+    averageTalkTime: number;
+    serviceLevel: number;
+    abandonRate: number;
+    answerRate: number;
+}
+export interface AgentMetrics {
+    agentId: string;
+    agentName: string;
+    callsHandled: number;
+    averageHandleTime: number;
+    averageTalkTime: number;
+    averageHoldTime: number;
+    occupancy: number;
+    availability: number;
+}
+export interface QueueMetrics {
+    queueId: string;
+    queueName: string;
+    callsInQueue: number;
+    oldestCallWaitTime: number;
+    averageWaitTime: number;
+    agentsAvailable: number;
+    agentsOnCall: number;
+}
+export interface CallInsight {
+    callId: string;
+    sentiment: 'positive' | 'neutral' | 'negative';
+    topics: string[];
+    keywords: string[];
+    issues: string[];
+    resolution: boolean;
+    customerSatisfaction?: number;
+}
+/**
+ * Call Analytics Module
+ */
+export declare class CallAnalytics {
+    /**
+     * Lambda code for aggregating call metrics
+     */
+    static MetricsAggregatorCode: string;
+    /**
+     * Lambda code for real-time queue metrics
+     */
+    static QueueMetricsCode: string;
+    /**
+     * Create metrics DynamoDB table
+     */
+    static createMetricsTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create metrics aggregator Lambda
+     */
+    static createMetricsAggregatorLambda(config: {
+        slug: string;
+        roleArn: string;
+        callLogTable: string;
+        metricsTable: string;
+    }): Record<string, any>;
+    /**
+     * Create EventBridge rule for hourly metrics
+     */
+    static createMetricsSchedule(config: {
+        slug: string;
+        lambdaArn: string;
+    }): Record<string, any>;
+}
+export default CallAnalytics;

package/dist/phone/advanced/callbacks.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Callback Requests and Queue Management
+ *
+ * Provides callback scheduling and queue management
+ */
+export interface CallbackRequest {
+    id: string;
+    phoneNumber: string;
+    customerName?: string;
+    reason?: string;
+    preferredTime?: string;
+    queueId?: string;
+    priority: number;
+    status: 'pending' | 'scheduled' | 'in-progress' | 'completed' | 'failed' | 'cancelled';
+    attempts: number;
+    maxAttempts: number;
+    createdAt: string;
+    scheduledFor?: string;
+    completedAt?: string;
+    notes?: string;
+}
+export interface QueuePosition {
+    position: number;
+    estimatedWaitTime: number;
+    callersAhead: number;
+}
+/**
+ * Callback Module
+ */
+export declare class Callbacks {
+    /**
+     * Lambda code for callback request handling
+     */
+    static CallbackRequestCode: string;
+    /**
+     * Lambda code for processing callbacks
+     */
+    static CallbackProcessorCode: string;
+    /**
+     * Create callbacks DynamoDB table
+     */
+    static createCallbacksTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create callback request Lambda
+     */
+    static createCallbackRequestLambda(config: {
+        slug: string;
+        roleArn: string;
+        callbacksTable: string;
+        notificationTopicArn?: string;
+    }): Record<string, any>;
+    /**
+     * Create callback processor Lambda
+     */
+    static createCallbackProcessorLambda(config: {
+        slug: string;
+        roleArn: string;
+        callbacksTable: string;
+        connectInstanceId: string;
+        contactFlowId: string;
+        sourcePhoneNumber: string;
+        queueId?: string;
+    }): Record<string, any>;
+}
+export default Callbacks;

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

@@ -0,0 +1,7 @@
+/**
+ * Phone Advanced Features
+ */
+export * from './recording';
+export * from './ivr-builder';
+export * from './analytics';
+export * from './callbacks';

package/dist/phone/advanced/ivr-builder.d.ts

@@ -0,0 +1,130 @@
+/**
+ * IVR Builder (Visual Contact Flow Editor)
+ *
+ * Provides a programmatic way to build Amazon Connect contact flows
+ */
+export interface IVRFlow {
+    id: string;
+    name: string;
+    description?: string;
+    nodes: IVRNode[];
+    connections: IVRConnection[];
+    startNodeId: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface IVRNode {
+    id: string;
+    type: IVRNodeType;
+    position: {
+        x: number;
+        y: number;
+    };
+    config: Record<string, any>;
+    label?: string;
+}
+export type IVRNodeType = 'start' | 'play-prompt' | 'get-input' | 'menu' | 'transfer-queue' | 'transfer-agent' | 'transfer-phone' | 'invoke-lambda' | 'set-attribute' | 'check-attribute' | 'check-hours' | 'check-queue' | 'record-voicemail' | 'disconnect' | 'loop' | 'wait';
+export interface IVRConnection {
+    id: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    sourcePort: string;
+    label?: string;
+}
+/**
+ * IVR Builder Module
+ */
+export declare class IVRBuilder {
+    private nodes;
+    private connections;
+    private startNodeId;
+    /**
+     * Create a new IVR flow
+     */
+    static create(name: string): IVRBuilder;
+    /**
+     * Add a start node
+     */
+    start(): this;
+    /**
+     * Add a play prompt node
+     */
+    playPrompt(text: string, options?: {
+        ssml?: boolean;
+        voice?: string;
+    }): this;
+    /**
+     * Add a get input node (DTMF)
+     */
+    getInput(prompt: string, options?: {
+        maxDigits?: number;
+        timeout?: number;
+        errorPrompt?: string;
+    }): this;
+    /**
+     * Add a menu node
+     */
+    menu(prompt: string, options: Record<string, string>): this;
+    /**
+     * Add a transfer to queue node
+     */
+    transferToQueue(queueArn: string, options?: {
+        priority?: number;
+    }): this;
+    /**
+     * Add a transfer to phone number node
+     */
+    transferToPhone(phoneNumber: string): this;
+    /**
+     * Add a Lambda invocation node
+     */
+    invokeLambda(functionArn: string, options?: {
+        timeout?: number;
+    }): this;
+    /**
+     * Add a set attribute node
+     */
+    setAttribute(key: string, value: string): this;
+    /**
+     * Add a check hours node
+     */
+    checkHours(hoursOfOperationArn: string): this;
+    /**
+     * Add a record voicemail node
+     */
+    recordVoicemail(options?: {
+        maxDuration?: number;
+        greeting?: string;
+        beep?: boolean;
+    }): this;
+    /**
+     * Add a wait node
+     */
+    wait(seconds: number): this;
+    /**
+     * Add a disconnect node
+     */
+    disconnect(): this;
+    /**
+     * Build the IVR flow
+     */
+    build(): IVRFlow;
+    /**
+     * Convert to Amazon Connect contact flow format
+     */
+    toContactFlow(): string;
+    private nodeToAction;
+    private connectToLast;
+    private getNextNodeId;
+    private generateId;
+    /**
+     * Pre-built IVR templates
+     */
+    static readonly Templates: {
+        basicSupport: () => IVRBuilder;
+        afterHours: (greeting: string) => IVRBuilder;
+        callbackRequest: (lambdaArn: string) => IVRBuilder;
+    };
+}
+export default IVRBuilder;

package/dist/phone/advanced/recording.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Call Recording with Transcription
+ *
+ * Provides call recording storage and transcription
+ */
+export interface CallRecording {
+    recordingId: string;
+    contactId: string;
+    startTime: string;
+    endTime: string;
+    duration: number;
+    participants: string[];
+    recordingUrl: string;
+    transcription?: CallTranscription;
+    status: 'recording' | 'processing' | 'completed' | 'failed';
+    createdAt: string;
+}
+export interface CallTranscription {
+    transcriptId: string;
+    text: string;
+    segments: TranscriptionSegment[];
+    language: string;
+    confidence: number;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+}
+export interface TranscriptionSegment {
+    speaker: string;
+    startTime: number;
+    endTime: number;
+    text: string;
+    confidence: number;
+    sentiment?: 'positive' | 'neutral' | 'negative';
+}
+/**
+ * Call Recording Module
+ */
+export declare class CallRecording {
+    /**
+     * Lambda code for processing call recordings
+     */
+    static RecordingProcessorCode: string;
+    /**
+     * Lambda code for transcription completion
+     */
+    static TranscriptionCompleteCode: string;
+    /**
+     * Create recordings DynamoDB table
+     */
+    static createRecordingsTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create recording processor Lambda
+     */
+    static createRecordingProcessorLambda(config: {
+        slug: string;
+        roleArn: string;
+        recordingBucket: string;
+        recordingsTable: string;
+    }): Record<string, any>;
+}
+export default CallRecording;

package/dist/phone/handlers/__tests__/incoming-call.test.d.ts

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

package/dist/phone/handlers/incoming-call.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Incoming Call Lambda Handler
+ *
+ * Processes incoming calls from Amazon Connect:
+ * - Logs call details
+ * - Sends notifications (SNS, webhook)
+ * - Routes based on caller ID
+ */
+export declare const handler = "\nconst { SNSClient, PublishCommand } = require('@aws-sdk/client-sns');\nconst { DynamoDBClient, PutItemCommand } = require('@aws-sdk/client-dynamodb');\n\nconst sns = new SNSClient({});\nconst dynamodb = new DynamoDBClient({});\n\nexports.handler = async (event) => {\n  console.log('Incoming call event:', JSON.stringify(event, null, 2));\n\n  const notificationTopicArn = process.env.NOTIFICATION_TOPIC_ARN;\n  const callLogTable = process.env.CALL_LOG_TABLE;\n  const webhookUrl = process.env.WEBHOOK_URL;\n\n  try {\n    // Extract call details from Connect event\n    const contactData = event.Details?.ContactData || {};\n    const parameters = event.Details?.Parameters || {};\n\n    const callDetails = {\n      contactId: contactData.ContactId,\n      channel: contactData.Channel || 'VOICE',\n      initiationMethod: contactData.InitiationMethod,\n      customerEndpoint: contactData.CustomerEndpoint?.Address,\n      systemEndpoint: contactData.SystemEndpoint?.Address,\n      queue: contactData.Queue?.Name,\n      attributes: contactData.Attributes || {},\n      timestamp: new Date().toISOString(),\n    };\n\n    console.log('Call details:', callDetails);\n\n    // Log call to DynamoDB\n    if (callLogTable) {\n      await dynamodb.send(new PutItemCommand({\n        TableName: callLogTable,\n        Item: {\n          contactId: { S: callDetails.contactId },\n          timestamp: { S: callDetails.timestamp },\n          callerNumber: { S: callDetails.customerEndpoint || 'unknown' },\n          calledNumber: { S: callDetails.systemEndpoint || 'unknown' },\n          channel: { S: callDetails.channel },\n          initiationMethod: { S: callDetails.initiationMethod || 'unknown' },\n          status: { S: 'incoming' },\n          ttl: { N: String(Math.floor(Date.now() / 1000) + 90 * 24 * 60 * 60) }, // 90 days\n        },\n      }));\n    }\n\n    // Send SNS notification\n    if (notificationTopicArn) {\n      await sns.send(new PublishCommand({\n        TopicArn: notificationTopicArn,\n        Subject: 'Incoming Call',\n        Message: JSON.stringify({\n          type: 'incoming_call',\n          from: callDetails.customerEndpoint,\n          to: callDetails.systemEndpoint,\n          contactId: callDetails.contactId,\n          timestamp: callDetails.timestamp,\n        }, null, 2),\n        MessageAttributes: {\n          eventType: {\n            DataType: 'String',\n            StringValue: 'incoming_call',\n          },\n        },\n      }));\n    }\n\n    // Send webhook notification\n    if (webhookUrl) {\n      try {\n        await fetch(webhookUrl, {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({\n            event: 'incoming_call',\n            data: callDetails,\n          }),\n        });\n      }\ncatch (err) {\n        console.error('Webhook notification failed:', err.message);\n      }\n    }\n\n    // Return routing decision\n    // Can be customized based on caller ID, time of day, etc.\n    return {\n      statusCode: 200,\n      route: parameters.defaultRoute || 'main_queue',\n      callerInfo: {\n        number: callDetails.customerEndpoint,\n        isKnown: false, // Could lookup in CRM\n      },\n    };\n\n  }\ncatch (error) {\n    console.error('Error processing incoming call:', error);\n    return {\n      statusCode: 500,\n      error: error.message,\n    };\n  }\n};\n";
+export default handler;

package/dist/phone/handlers/missed-call.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Missed Call Lambda Handler
+ *
+ * Processes missed call events:
+ * - Logs missed call
+ * - Sends notification
+ */
+export declare const handler = "\nconst { SNSClient, PublishCommand } = require('@aws-sdk/client-sns');\nconst { DynamoDBClient, UpdateItemCommand } = require('@aws-sdk/client-dynamodb');\n\nconst sns = new SNSClient({});\nconst dynamodb = new DynamoDBClient({});\n\nexports.handler = async (event) => {\n  console.log('Missed call event:', JSON.stringify(event, null, 2));\n\n  const notificationTopicArn = process.env.NOTIFICATION_TOPIC_ARN;\n  const callLogTable = process.env.CALL_LOG_TABLE;\n  const webhookUrl = process.env.WEBHOOK_URL;\n\n  try {\n    // Extract call details from Connect event\n    const contactData = event.Details?.ContactData || {};\n\n    const callDetails = {\n      contactId: contactData.ContactId,\n      customerEndpoint: contactData.CustomerEndpoint?.Address,\n      systemEndpoint: contactData.SystemEndpoint?.Address,\n      queue: contactData.Queue?.Name,\n      waitTime: contactData.Queue?.EnqueueTimestamp\n        ? Math.floor((Date.now() - new Date(contactData.Queue.EnqueueTimestamp).getTime()) / 1000)\n        : 0,\n      disconnectReason: event.Details?.Parameters?.disconnectReason || 'customer_abandoned',\n      timestamp: new Date().toISOString(),\n    };\n\n    console.log('Missed call details:', callDetails);\n\n    // Update call log\n    if (callLogTable && callDetails.contactId) {\n      await dynamodb.send(new UpdateItemCommand({\n        TableName: callLogTable,\n        Key: {\n          contactId: { S: callDetails.contactId },\n        },\n        UpdateExpression: 'SET #status = :status, disconnectReason = :reason, waitTime = :wait, missedAt = :at',\n        ExpressionAttributeNames: {\n          '#status': 'status',\n        },\n        ExpressionAttributeValues: {\n          ':status': { S: 'missed' },\n          ':reason': { S: callDetails.disconnectReason },\n          ':wait': { N: String(callDetails.waitTime) },\n          ':at': { S: callDetails.timestamp },\n        },\n      }));\n    }\n\n    // Send SNS notification\n    if (notificationTopicArn) {\n      await sns.send(new PublishCommand({\n        TopicArn: notificationTopicArn,\n        Subject: 'Missed Call Alert',\n        Message: JSON.stringify({\n          type: 'missed_call',\n          from: callDetails.customerEndpoint,\n          to: callDetails.systemEndpoint,\n          queue: callDetails.queue,\n          waitTime: callDetails.waitTime,\n          reason: callDetails.disconnectReason,\n          contactId: callDetails.contactId,\n          timestamp: callDetails.timestamp,\n        }, null, 2),\n        MessageAttributes: {\n          eventType: {\n            DataType: 'String',\n            StringValue: 'missed_call',\n          },\n        },\n      }));\n    }\n\n    // Send webhook notification\n    if (webhookUrl) {\n      try {\n        await fetch(webhookUrl, {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({\n            event: 'missed_call',\n            data: callDetails,\n          }),\n        });\n      }\ncatch (err) {\n        console.error('Webhook notification failed:', err.message);\n      }\n    }\n\n    return {\n      statusCode: 200,\n      message: 'Missed call logged',\n    };\n\n  }\ncatch (error) {\n    console.error('Error processing missed call:', error);\n    return {\n      statusCode: 500,\n      error: error.message,\n    };\n  }\n};\n";
+export default handler;

package/dist/phone/handlers/voicemail.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Voicemail Lambda Handler
+ *
+ * Processes voicemail recordings:
+ * - Processes voicemail recordings from S3
+ * - Transcribes using Amazon Transcribe
+ * - Sends notification with transcription
+ */
+export declare const handler = "\nconst { S3Client, GetObjectCommand, PutObjectCommand } = require('@aws-sdk/client-s3');\nconst { TranscribeClient, StartTranscriptionJobCommand, GetTranscriptionJobCommand } = require('@aws-sdk/client-transcribe');\nconst { SNSClient, PublishCommand } = require('@aws-sdk/client-sns');\nconst { DynamoDBClient, UpdateItemCommand } = require('@aws-sdk/client-dynamodb');\n\nconst s3 = new S3Client({});\nconst transcribe = new TranscribeClient({});\nconst sns = new SNSClient({});\nconst dynamodb = new DynamoDBClient({});\n\nexports.handler = async (event) => {\n  console.log('Voicemail event:', JSON.stringify(event, null, 2));\n\n  const notificationTopicArn = process.env.NOTIFICATION_TOPIC_ARN;\n  const voicemailBucket = process.env.VOICEMAIL_BUCKET;\n  const callLogTable = process.env.CALL_LOG_TABLE;\n  const transcriptionEnabled = process.env.TRANSCRIPTION_ENABLED === 'true';\n\n  for (const record of event.Records) {\n    try {\n      const s3Event = record.s3 || {};\n      const bucket = s3Event.bucket?.name || voicemailBucket;\n      const key = decodeURIComponent(s3Event.object?.key?.replace(/\\+/g, ' ') || '');\n\n      if (!key.includes('voicemail') || !key.endsWith('.wav')) {\n        continue;\n      }\n\n      console.log(`Processing voicemail: ${key}`);\n\n      // Extract metadata from key (format: voicemails/{contactId}/{timestamp}.wav)\n      const parts = key.split('/');\n      const contactId = parts[1] || 'unknown';\n      const filename = parts[parts.length - 1];\n      const timestamp = filename.replace('.wav', '');\n\n      // Get voicemail metadata if exists\n      let metadata = {};\n      try {\n        const metaResult = await s3.send(new GetObjectCommand({\n          Bucket: bucket,\n          Key: key.replace('.wav', '.json'),\n        }));\n        metadata = JSON.parse(await metaResult.Body.transformToString());\n      }\ncatch {\n        // No metadata file\n      }\n\n      let transcription = null;\n\n      // Start transcription if enabled\n      if (transcriptionEnabled) {\n        const jobName = `voicemail-${contactId}-${Date.now()}`;\n\n        await transcribe.send(new StartTranscriptionJobCommand({\n          TranscriptionJobName: jobName,\n          LanguageCode: 'en-US',\n          MediaFormat: 'wav',\n          Media: {\n            MediaFileUri: `s3://${bucket}/${key}`,\n          },\n          OutputBucketName: bucket,\n          OutputKey: key.replace('.wav', '-transcript.json'),\n        }));\n\n        // Wait for transcription (with timeout)\n        let attempts = 0;\n        const maxAttempts = 30; // 5 minutes max\n\n        while (attempts < maxAttempts) {\n          await new Promise(resolve => setTimeout(resolve, 10000)); // 10 seconds\n\n          const jobResult = await transcribe.send(new GetTranscriptionJobCommand({\n            TranscriptionJobName: jobName,\n          }));\n\n          const status = jobResult.TranscriptionJob?.TranscriptionJobStatus;\n\n          if (status === 'COMPLETED') {\n            // Get transcription result\n            try {\n              const transcriptResult = await s3.send(new GetObjectCommand({\n                Bucket: bucket,\n                Key: key.replace('.wav', '-transcript.json'),\n              }));\n              const transcriptData = JSON.parse(await transcriptResult.Body.transformToString());\n              transcription = transcriptData.results?.transcripts?.[0]?.transcript || '';\n            }\ncatch (err) {\n              console.error('Error getting transcription:', err.message);\n            }\n            break;\n          }\nelse if (status === 'FAILED') {\n            console.error('Transcription failed');\n            break;\n          }\n\n          attempts++;\n        }\n      }\n\n      // Update call log\n      if (callLogTable && contactId !== 'unknown') {\n        await dynamodb.send(new UpdateItemCommand({\n          TableName: callLogTable,\n          Key: {\n            contactId: { S: contactId },\n          },\n          UpdateExpression: 'SET voicemailKey = :key, voicemailTranscript = :transcript, voicemailAt = :at',\n          ExpressionAttributeValues: {\n            ':key': { S: key },\n            ':transcript': { S: transcription || '' },\n            ':at': { S: new Date().toISOString() },\n          },\n        }));\n      }\n\n      // Save voicemail metadata\n      await s3.send(new PutObjectCommand({\n        Bucket: bucket,\n        Key: key.replace('.wav', '-metadata.json'),\n        Body: JSON.stringify({\n          contactId,\n          callerNumber: metadata.callerNumber || 'unknown',\n          calledNumber: metadata.calledNumber || 'unknown',\n          duration: metadata.duration || 0,\n          recordedAt: timestamp,\n          processedAt: new Date().toISOString(),\n          transcription,\n          audioKey: key,\n        }, null, 2),\n        ContentType: 'application/json',\n      }));\n\n      // Send notification\n      if (notificationTopicArn) {\n        await sns.send(new PublishCommand({\n          TopicArn: notificationTopicArn,\n          Subject: 'New Voicemail',\n          Message: JSON.stringify({\n            type: 'voicemail',\n            contactId,\n            from: metadata.callerNumber || 'unknown',\n            to: metadata.calledNumber || 'unknown',\n            duration: metadata.duration || 0,\n            transcription: transcription || '(transcription not available)',\n            audioUrl: `s3://${bucket}/${key}`,\n            timestamp: new Date().toISOString(),\n          }, null, 2),\n          MessageAttributes: {\n            eventType: {\n              DataType: 'String',\n              StringValue: 'voicemail',\n            },\n          },\n        }));\n      }\n\n      console.log(`Processed voicemail: ${contactId}`);\n\n    }\ncatch (error) {\n      console.error('Error processing voicemail:', error);\n    }\n  }\n\n  return { statusCode: 200, body: 'OK' };\n};\n";
+export default handler;

package/dist/phone/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Phone/Voice Advanced Features
+ */
+export * as PhoneAdvanced from './advanced';
+export * as PhoneHandlers from './handlers/incoming-call';

package/dist/presets/api-backend.d.ts

@@ -0,0 +1,11 @@
+import type { CloudConfig } from '../types';
+/**
+ * API-Only Backend Preset
+ * Perfect for: REST APIs, GraphQL APIs, mobile backends
+ * Includes: API Gateway + Lambda functions + DynamoDB
+ */
+export declare function createApiBackendPreset(options: {
+    name: string;
+    slug: string;
+    domain?: string;
+}): Partial<CloudConfig>;

package/dist/presets/data-pipeline.d.ts

@@ -0,0 +1,11 @@
+import type { CloudConfig } from '../types';
+/**
+ * Data Pipeline Preset
+ * Perfect for: ETL pipelines, data processing, analytics workflows
+ * Includes: Kinesis + Lambda + S3 + Athena + Glue
+ */
+export declare function createDataPipelinePreset(options: {
+    name: string;
+    slug: string;
+    retentionDays?: number;
+}): Partial<CloudConfig>;