@stacksjs/ts-cloud-core 0.1.6 → 0.1.7

package/dist/security/scanning.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Global security scanning manager instance
+ */
+export declare const securityScanningManager: SecurityScanningManager;
+/**
+ * Security Scanning & Vulnerability Assessment
+ * Automated security scanning, vulnerability detection, and compliance checking
+ */
+export declare interface SecurityScan {
+  id: string
+  name: string
+  scanType: ScanType
+  target: ScanTarget
+  status: 'queued' | 'running' | 'completed' | 'failed'
+  startedAt?: Date
+  completedAt?: Date
+  findings: SecurityFinding[]
+  summary?: ScanSummary
+}
+export declare interface ScanTarget {
+  type: 'ecr_image' | 'ec2_instance' | 'lambda' | 'api' | 'repository'
+  identifier: string
+  region?: string
+}
+export declare interface SecurityFinding {
+  id: string
+  severity: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW' | 'INFO'
+  title: string
+  description: string
+  cve?: string
+  cvss?: number
+  affectedResource: string
+  remediation?: string
+  status: 'OPEN' | 'SUPPRESSED' | 'RESOLVED'
+  firstDetected: Date
+  lastSeen: Date
+}
+export declare interface ScanSummary {
+  totalFindings: number
+  criticalCount: number
+  highCount: number
+  mediumCount: number
+  lowCount: number
+  infoCount: number
+  executionTime: number
+}
+export declare interface VulnerabilityReport {
+  id: string
+  scanId: string
+  reportType: 'summary' | 'detailed' | 'executive'
+  format: 'json' | 'pdf' | 'html'
+  generatedAt: Date
+  s3Location?: string
+}
+export declare interface ComplianceCheck {
+  id: string
+  framework: ComplianceFramework
+  checkId: string
+  title: string
+  description: string
+  status: 'PASS' | 'FAIL' | 'WARNING' | 'NOT_APPLICABLE'
+  severity: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW'
+  resourceType: string
+  resourceId: string
+  remediation?: string
+}
+export declare interface SecurityPosture {
+  id: string
+  accountId: string
+  region: string
+  score: number
+  grade: 'A' | 'B' | 'C' | 'D' | 'F'
+  assessedAt: Date
+  strengths: string[]
+  weaknesses: string[]
+  recommendations: string[]
+}
+export type ScanType = | 'vulnerability'
+  | 'container_image'
+  | 'code_quality'
+  | 'secrets_detection'
+  | 'compliance'
+  | 'penetration_test'
+export type ComplianceFramework = | 'CIS_AWS_FOUNDATIONS_1_4'
+  | 'CIS_AWS_FOUNDATIONS_1_2'
+  | 'PCI_DSS_3_2_1'
+  | 'HIPAA'
+  | 'SOC2'
+  | 'NIST_800_53'
+  | 'ISO_27001'
+/**
+ * Security scanning manager
+ */
+export declare class SecurityScanningManager {
+  private scans: Map<string, SecurityScan>;
+  private findings: Map<string, SecurityFinding>;
+  private reports: Map<string, VulnerabilityReport>;
+  private complianceChecks: Map<string, ComplianceCheck>;
+  private postures: Map<string, SecurityPosture>;
+  private scanCounter: any;
+  private findingCounter: any;
+  private reportCounter: any;
+  private checkCounter: any;
+  private postureCounter: any;
+  createScan(scan: Omit<SecurityScan, 'id' | 'status' | 'findings'>): SecurityScan;
+  createContainerScan(options: {
+    name: string
+    imageUri: string
+    region?: string
+  }): SecurityScan;
+  createLambdaScan(options: {
+    name: string
+    functionName: string
+    region?: string
+  }): SecurityScan;
+  createSecretsDetectionScan(options: {
+    name: string
+    repositoryUrl: string
+  }): SecurityScan;
+  executeScan(scanId: string): Promise<SecurityScan>;
+  private simulateFindings(scan: SecurityScan): SecurityFinding[];
+  createFinding(finding: Omit<SecurityFinding, 'id'>): SecurityFinding;
+  suppressFinding(findingId: string, reason?: string): void;
+  resolveFinding(findingId: string): void;
+  generateReport(options: {
+    scanId: string
+    reportType: 'summary' | 'detailed' | 'executive'
+    format: 'json' | 'pdf' | 'html'
+  }): VulnerabilityReport;
+  runComplianceCheck(options: {
+    framework: ComplianceFramework
+    resourceType: string
+    resourceId: string
+  }): ComplianceCheck[];
+  createComplianceCheck(check: Omit<ComplianceCheck, 'id'>): ComplianceCheck;
+  assessSecurityPosture(options: {
+    accountId: string
+    region: string
+  }): SecurityPosture;
+  getScan(id: string): SecurityScan | undefined;
+  listScans(): SecurityScan[];
+  getOpenFindings(severity?: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW' | 'INFO'): SecurityFinding[];
+  getComplianceChecksByStatus(status: 'PASS' | 'FAIL' | 'WARNING' | 'NOT_APPLICABLE'): ComplianceCheck[];
+  listPostures(): SecurityPosture[];
+  generateECRScanCF(repositoryName: string): any;
+  clear(): void;
+}

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

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

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

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

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

@@ -0,0 +1,54 @@
+/**
+ * A/B Testing for SMS Content
+ *
+ * Provides A/B testing capabilities for SMS campaigns
+ */
+export declare 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 declare interface AbVariant {
+  id: string
+  name: string
+  message: string
+  stats: VariantStats
+}
+export declare 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 {
+  static AbTestManagerCode: any;
+  static createAbTestsTable(config: { slug: string }): Record<string, any>;
+  static createAbTestManagerLambda(config: {
+    slug: string
+    roleArn: string
+    abTestsTable: string
+  }): Record<string, any>;
+  static selectVariant(test: AbTest, recipientId: string): AbVariant;
+  static determineWinner(test: AbTest): AbVariant | null;
+  static calculateSignificance(variantA: AbVariant, variantB: AbVariant, criteria: string): number;
+  static private getMetricValue(variant: AbVariant, criteria: string): number;
+  static private hashString(str: string): number;
+}
+export default AbTesting;

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

@@ -0,0 +1,56 @@
+/**
+ * SMS Analytics
+ *
+ * Provides delivery rates, engagement metrics, and reporting
+ */
+export declare interface SmsMetrics {
+  period: string
+  sent: number
+  delivered: number
+  failed: number
+  pending: number
+  optedOut: number
+  deliveryRate: number
+  failureRate: number
+  averageDeliveryTime: number
+  cost: number
+}
+export declare interface SmsEngagement {
+  messageId: string
+  delivered: boolean
+  deliveredAt?: string
+  clicked?: boolean
+  clickedAt?: string
+  replied?: boolean
+  repliedAt?: string
+  replyContent?: string
+  optedOut?: boolean
+  optedOutAt?: string
+}
+export declare 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 {
+  static AnalyticsAggregatorCode: any;
+  static DeliveryTrackerCode: any;
+  static createAnalyticsTable(config: { slug: string }): Record<string, any>;
+  static createDeliveryReportsTable(config: { slug: string }): Record<string, any>;
+  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,82 @@
+/**
+ * SMS Campaigns and Scheduling
+ *
+ * Provides campaign management and scheduled SMS sending
+ */
+export declare 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 declare interface CampaignAudience {
+  type: 'list' | 'segment' | 'all'
+  listId?: string
+  segmentId?: string
+  filters?: AudienceFilter[]
+  estimatedSize?: number
+}
+export declare interface AudienceFilter {
+  field: string
+  operator: 'equals' | 'not-equals' | 'contains' | 'greater-than' | 'less-than'
+  value: string
+}
+export declare interface CampaignSchedule {
+  type: 'immediate' | 'scheduled' | 'recurring'
+  scheduledFor?: string
+  timezone?: string
+  recurrence?: {
+    frequency: 'daily' | 'weekly' | 'monthly'
+    interval: number
+    endDate?: string
+    maxOccurrences?: number
+  }
+}
+export declare interface CampaignSettings {
+  messageType: 'TRANSACTIONAL' | 'PROMOTIONAL'
+  senderId?: string
+  originationNumber?: string
+  throttleRate?: number
+  quietHours?: {
+    start: string // HH:MM
+    end: string
+    timezone: string
+  }
+  optOutHandling: boolean
+}
+export declare interface CampaignStats {
+  totalRecipients: number
+  sent: number
+  delivered: number
+  failed: number
+  optedOut: number
+  deliveryRate: number
+  cost: number
+}
+/**
+ * SMS Campaigns Module
+ */
+export declare class SmsCampaigns {
+  static CampaignManagerCode: any;
+  static CampaignExecutorCode: any;
+  static createCampaignsTable(config: { slug: string }): Record<string, any>;
+  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,48 @@
+/**
+ * SMS Chatbot Integration
+ *
+ * Provides conversational SMS with AI/rule-based responses
+ */
+export declare interface ChatbotConfig {
+  enabled: boolean
+  provider: 'rules' | 'bedrock' | 'openai' | 'custom'
+  welcomeMessage?: string
+  fallbackMessage?: string
+  sessionTimeout?: number
+  maxTurns?: number
+}
+export declare interface ChatSession {
+  sessionId: string
+  phoneNumber: string
+  startedAt: string
+  lastMessageAt: string
+  turnCount: number
+  context: Record<string, any>
+  status: 'active' | 'ended' | 'timeout'
+}
+export declare 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 {
+  static ChatbotProcessorCode: string;
+  static createSessionsTable(config: { slug: string }): Record<string, any>;
+  static createRulesTable(config: { slug: string }): Record<string, any>;
+  static createChatbotProcessorLambda(config: {
+    slug: string
+    roleArn: string
+    sessionsTable: string
+    rulesTable: string
+    chatbotConfig: ChatbotConfig
+    originationNumber?: string
+  }): Record<string, any>;
+  static readonly DefaultRules: ChatRule[];
+}
+export default SmsChatbot;

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

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

package/dist/sms/advanced/link-tracking.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Link Shortening and Tracking
+ *
+ * Provides URL shortening and click tracking for SMS
+ */
+export declare interface ShortenedLink {
+  id: string
+  originalUrl: string
+  shortUrl: string
+  campaignId?: string
+  messageId?: string
+  clicks: number
+  uniqueClicks: number
+  createdAt: string
+  expiresAt?: string
+}
+export declare interface LinkClick {
+  linkId: string
+  clickedAt: string
+  userAgent?: string
+  ipAddress?: string
+  country?: string
+  device?: string
+}
+/**
+ * Link Tracking Module
+ */
+export declare class LinkTracking {
+  static LinkShortenerCode: any;
+  static createLinksTable(config: { slug: string }): Record<string, any>;
+  static createLinkShortenerLambda(config: {
+    slug: string
+    roleArn: string
+    linksTable: string
+    shortDomain?: string
+  }): Record<string, any>;
+  static shortenUrlsInMessage(message: string, shortDomain: string, linkIdPrefix: string): {
+    message: string
+    links: Array<{ original: string; short: string; id: string }>
+  };
+}
+export default LinkTracking;