@ts-cloud/core 0.2.2 → 0.2.4

package/dist/s3/index.d.ts

@@ -0,0 +1,227 @@
+/**
+ * S3 Advanced Features
+ * Object Lock, Transfer Acceleration, Access Points, Glacier, Inventory, Batch Operations, Event Notifications
+ */
+export interface LifecyclePolicy {
+    id: string;
+    transitions: Array<{
+        days: number;
+        storageClass: string;
+    }>;
+    expiration?: number;
+}
+export interface VersioningConfig {
+    id: string;
+    enabled: boolean;
+    mfaDelete: boolean;
+}
+export interface ReplicationRule {
+    id: string;
+    sourceRegion: string;
+    destRegion: string;
+    destBucket: string;
+}
+export interface IntelligentTieringConfig {
+    id: string;
+    archiveDays: number;
+    deepArchiveDays: number;
+}
+export interface ObjectLockConfig {
+    id: string;
+    bucketName: string;
+    mode: 'COMPLIANCE' | 'GOVERNANCE';
+    retentionDays?: number;
+    retentionYears?: number;
+    legalHoldEnabled: boolean;
+}
+export interface TransferAccelerationConfig {
+    id: string;
+    bucketName: string;
+    enabled: boolean;
+    endpoint: string;
+}
+export interface AccessPoint {
+    id: string;
+    name: string;
+    bucketName: string;
+    vpcId?: string;
+    publicAccessBlock: boolean;
+    policy?: Record<string, any>;
+}
+export interface GlacierArchiveConfig {
+    id: string;
+    bucketName: string;
+    archiveType: 'GLACIER' | 'DEEP_ARCHIVE';
+    transitionDays: number;
+    restoreConfig?: {
+        tier: 'Expedited' | 'Standard' | 'Bulk';
+        days: number;
+    };
+}
+export interface InventoryConfig {
+    id: string;
+    sourceBucket: string;
+    destinationBucket: string;
+    schedule: 'Daily' | 'Weekly';
+    format: 'CSV' | 'ORC' | 'Parquet';
+    includedFields: string[];
+    prefix?: string;
+}
+export interface BatchOperation {
+    id: string;
+    operation: 'Copy' | 'Delete' | 'RestoreObject' | 'Tagging' | 'ACL' | 'ObjectLock';
+    manifestBucket: string;
+    manifestKey: string;
+    priority: number;
+    status: 'pending' | 'in_progress' | 'completed' | 'failed';
+    totalObjects?: number;
+    processedObjects?: number;
+}
+export interface EventNotification {
+    id: string;
+    bucketName: string;
+    events: Array<'s3:ObjectCreated:*' | 's3:ObjectRemoved:*' | 's3:ObjectRestore:*' | 's3:Replication:*'>;
+    destination: {
+        type: 'Lambda' | 'SQS' | 'SNS';
+        arn: string;
+    };
+    filter?: {
+        prefix?: string;
+        suffix?: string;
+    };
+}
+export declare class StorageAdvancedManager {
+    private policies;
+    private versioningConfigs;
+    private replicationRules;
+    private tieringConfigs;
+    private objectLocks;
+    private transferAcceleration;
+    private accessPoints;
+    private glacierConfigs;
+    private inventories;
+    private batchOps;
+    private eventNotifications;
+    private counter;
+    createLifecyclePolicy(transitions: Array<{
+        days: number;
+        storageClass: string;
+    }>, expiration?: number): LifecyclePolicy;
+    enableVersioning(mfaDelete?: boolean): VersioningConfig;
+    createReplicationRule(sourceRegion: string, destRegion: string, destBucket: string): ReplicationRule;
+    createIntelligentTiering(archiveDays: number, deepArchiveDays: number): IntelligentTieringConfig;
+    /**
+     * Enable S3 Object Lock in compliance mode
+     */
+    enableObjectLock(options: {
+        bucketName: string;
+        mode?: 'COMPLIANCE' | 'GOVERNANCE';
+        retentionDays?: number;
+        retentionYears?: number;
+        legalHoldEnabled?: boolean;
+    }): ObjectLockConfig;
+    /**
+     * Enable S3 Transfer Acceleration
+     */
+    enableTransferAcceleration(bucketName: string): TransferAccelerationConfig;
+    /**
+     * Create S3 Access Point
+     */
+    createAccessPoint(options: {
+        name: string;
+        bucketName: string;
+        vpcId?: string;
+        publicAccessBlock?: boolean;
+        policy?: Record<string, any>;
+    }): AccessPoint;
+    /**
+     * Configure Glacier Deep Archive
+     */
+    createGlacierArchive(options: {
+        bucketName: string;
+        archiveType: 'GLACIER' | 'DEEP_ARCHIVE';
+        transitionDays: number;
+        restoreTier?: 'Expedited' | 'Standard' | 'Bulk';
+        restoreDays?: number;
+    }): GlacierArchiveConfig;
+    /**
+     * Create S3 Inventory configuration
+     */
+    createInventory(options: {
+        sourceBucket: string;
+        destinationBucket: string;
+        schedule?: 'Daily' | 'Weekly';
+        format?: 'CSV' | 'ORC' | 'Parquet';
+        includedFields?: string[];
+        prefix?: string;
+    }): InventoryConfig;
+    /**
+     * Create S3 Batch Operation
+     */
+    createBatchOperation(options: {
+        operation: 'Copy' | 'Delete' | 'RestoreObject' | 'Tagging' | 'ACL' | 'ObjectLock';
+        manifestBucket: string;
+        manifestKey: string;
+        priority?: number;
+    }): BatchOperation;
+    /**
+     * Execute batch operation
+     */
+    executeBatchOperation(batchOpId: string): BatchOperation;
+    /**
+     * Get batch operation status
+     */
+    getBatchOperationStatus(batchOpId: string): BatchOperation | undefined;
+    /**
+     * Create S3 Event Notification for Lambda
+     */
+    createLambdaNotification(options: {
+        bucketName: string;
+        lambdaArn: string;
+        events: Array<'s3:ObjectCreated:*' | 's3:ObjectRemoved:*' | 's3:ObjectRestore:*' | 's3:Replication:*'>;
+        prefix?: string;
+        suffix?: string;
+    }): EventNotification;
+    /**
+     * Create S3 Event Notification for SQS
+     */
+    createSQSNotification(options: {
+        bucketName: string;
+        queueArn: string;
+        events: Array<'s3:ObjectCreated:*' | 's3:ObjectRemoved:*' | 's3:ObjectRestore:*' | 's3:Replication:*'>;
+        prefix?: string;
+        suffix?: string;
+    }): EventNotification;
+    /**
+     * Create S3 Event Notification for SNS
+     */
+    createSNSNotification(options: {
+        bucketName: string;
+        topicArn: string;
+        events: Array<'s3:ObjectCreated:*' | 's3:ObjectRemoved:*' | 's3:ObjectRestore:*' | 's3:Replication:*'>;
+        prefix?: string;
+        suffix?: string;
+    }): EventNotification;
+    /**
+     * Generate CloudFormation for Object Lock
+     */
+    generateObjectLockCF(config: ObjectLockConfig): any;
+    /**
+     * Generate CloudFormation for Transfer Acceleration
+     */
+    generateTransferAccelerationCF(config: TransferAccelerationConfig): any;
+    /**
+     * Generate CloudFormation for Access Point
+     */
+    generateAccessPointCF(accessPoint: AccessPoint): any;
+    /**
+     * Generate CloudFormation for Inventory
+     */
+    generateInventoryCF(inventory: InventoryConfig): any;
+    /**
+     * Generate CloudFormation for Event Notification
+     */
+    generateEventNotificationCF(notification: EventNotification): any;
+    clear(): void;
+}
+export declare const storageAdvancedManager: StorageAdvancedManager;

package/dist/schema/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * JSON Schema export for IDE integration
+ */
+import schema from './cloud-config.schema.json';
+export { schema as cloudConfigSchema };
+/**
+ * Validate configuration against JSON schema
+ */
+export declare function validateAgainstSchema(config: any): {
+    valid: boolean;
+    errors: string[];
+};

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

@@ -0,0 +1,184 @@
+/**
+ * Certificate Lifecycle Management
+ * Automated certificate provisioning, renewal, and monitoring
+ */
+export interface Certificate {
+    id: string;
+    arn: string;
+    domainName: string;
+    subjectAlternativeNames?: string[];
+    validationMethod: 'DNS' | 'EMAIL';
+    status: CertificateStatus;
+    issuer?: string;
+    issuedAt?: Date;
+    expiresAt?: Date;
+    renewalEligibility?: boolean;
+    inUseBy?: string[];
+}
+export type CertificateStatus = 'PENDING_VALIDATION' | 'ISSUED' | 'INACTIVE' | 'EXPIRED' | 'VALIDATION_TIMED_OUT' | 'REVOKED' | 'FAILED';
+export interface CertificateRenewal {
+    id: string;
+    certificateArn: string;
+    autoRenew: boolean;
+    renewBeforeDays: number;
+    lastRenewal?: Date;
+    nextRenewal?: Date;
+    renewalStatus?: 'success' | 'pending' | 'failed';
+}
+export interface CertificateValidation {
+    domainName: string;
+    validationMethod: 'DNS' | 'EMAIL';
+    validationStatus: 'PENDING' | 'SUCCESS' | 'FAILED';
+    resourceRecords?: DnsRecord[];
+    validationEmails?: string[];
+}
+export interface DnsRecord {
+    name: string;
+    type: 'CNAME' | 'A' | 'AAAA' | 'TXT';
+    value: string;
+}
+export interface CertificateMonitor {
+    id: string;
+    name: string;
+    certificates: string[];
+    expirationThreshold: number;
+    alertEnabled: boolean;
+    snsTopicArn?: string;
+}
+export interface CertificateAlert {
+    id: string;
+    certificateArn: string;
+    alertType: 'expiring_soon' | 'expired' | 'renewal_failed' | 'validation_failed';
+    severity: 'critical' | 'warning' | 'info';
+    message: string;
+    timestamp: Date;
+    acknowledged?: boolean;
+}
+/**
+ * Certificate manager
+ */
+export declare class CertificateManager {
+    private certificates;
+    private renewals;
+    private validations;
+    private monitors;
+    private alerts;
+    private certificateCounter;
+    private renewalCounter;
+    private validationCounter;
+    private monitorCounter;
+    private alertCounter;
+    /**
+     * Request certificate
+     */
+    requestCertificate(options: {
+        domainName: string;
+        subjectAlternativeNames?: string[];
+        validationMethod?: 'DNS' | 'EMAIL';
+    }): Certificate;
+    /**
+     * Request wildcard certificate
+     */
+    requestWildcardCertificate(options: {
+        domainName: string;
+        includeApex?: boolean;
+    }): Certificate;
+    /**
+     * Request multi-domain certificate
+     */
+    requestMultiDomainCertificate(options: {
+        primaryDomain: string;
+        additionalDomains: string[];
+        validationMethod?: 'DNS' | 'EMAIL';
+    }): Certificate;
+    /**
+     * Create certificate validation
+     */
+    private createValidation;
+    /**
+     * Validate certificate
+     */
+    validateCertificate(certificateId: string): {
+        success: boolean;
+        message: string;
+    };
+    /**
+     * Enable auto-renewal
+     */
+    enableAutoRenewal(options: {
+        certificateArn: string;
+        renewBeforeDays?: number;
+    }): CertificateRenewal;
+    /**
+     * Renew certificate
+     */
+    renewCertificate(renewalId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Create certificate monitor
+     */
+    createMonitor(monitor: Omit<CertificateMonitor, 'id'>): CertificateMonitor;
+    /**
+     * Check certificate expiration
+     */
+    checkExpiration(): CertificateAlert[];
+    /**
+     * Create alert
+     */
+    createAlert(alert: Omit<CertificateAlert, 'id' | 'timestamp' | 'acknowledged'>): CertificateAlert;
+    /**
+     * Acknowledge alert
+     */
+    acknowledgeAlert(alertId: string): void;
+    /**
+     * Get certificate
+     */
+    getCertificate(id: string): Certificate | undefined;
+    /**
+     * List certificates
+     */
+    listCertificates(): Certificate[];
+    /**
+     * Get expiring certificates
+     */
+    getExpiringCertificates(days?: number): Certificate[];
+    /**
+     * Get validation
+     */
+    getValidation(certificateId: string): CertificateValidation | undefined;
+    /**
+     * Get renewal
+     */
+    getRenewal(id: string): CertificateRenewal | undefined;
+    /**
+     * List renewals
+     */
+    listRenewals(): CertificateRenewal[];
+    /**
+     * List alerts
+     */
+    listAlerts(acknowledged?: boolean): CertificateAlert[];
+    /**
+     * Generate CloudFormation for certificate
+     */
+    generateCertificateCF(certificate: Certificate): any;
+    /**
+     * Generate CloudWatch alarm for expiration
+     */
+    generateExpirationAlarmCF(options: {
+        alarmName: string;
+        certificateArn: string;
+        daysBeforeExpiration: number;
+        snsTopicArn?: string;
+    }): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global certificate manager instance
+ */
+export declare const certificateManager: CertificateManager;

package/dist/security/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Security Module
+ * Secrets management, certificate lifecycle, and security scanning
+ */
+export * from './secrets-rotation';
+export * from './secrets-manager';
+export * from './certificate-manager';
+export * from './scanning';

package/dist/security/scanning.d.ts

@@ -0,0 +1,196 @@
+/**
+ * Security Scanning & Vulnerability Assessment
+ * Automated security scanning, vulnerability detection, and compliance checking
+ */
+export interface SecurityScan {
+    id: string;
+    name: string;
+    scanType: ScanType;
+    target: ScanTarget;
+    status: 'queued' | 'running' | 'completed' | 'failed';
+    startedAt?: Date;
+    completedAt?: Date;
+    findings: SecurityFinding[];
+    summary?: ScanSummary;
+}
+export type ScanType = 'vulnerability' | 'container_image' | 'code_quality' | 'secrets_detection' | 'compliance' | 'penetration_test';
+export interface ScanTarget {
+    type: 'ecr_image' | 'ec2_instance' | 'lambda' | 'api' | 'repository';
+    identifier: string;
+    region?: string;
+}
+export 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 interface ScanSummary {
+    totalFindings: number;
+    criticalCount: number;
+    highCount: number;
+    mediumCount: number;
+    lowCount: number;
+    infoCount: number;
+    executionTime: number;
+}
+export interface VulnerabilityReport {
+    id: string;
+    scanId: string;
+    reportType: 'summary' | 'detailed' | 'executive';
+    format: 'json' | 'pdf' | 'html';
+    generatedAt: Date;
+    s3Location?: string;
+}
+export 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 type ComplianceFramework = 'CIS_AWS_FOUNDATIONS_1_4' | 'CIS_AWS_FOUNDATIONS_1_2' | 'PCI_DSS_3_2_1' | 'HIPAA' | 'SOC2' | 'NIST_800_53' | 'ISO_27001';
+export interface SecurityPosture {
+    id: string;
+    accountId: string;
+    region: string;
+    score: number;
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+    assessedAt: Date;
+    strengths: string[];
+    weaknesses: string[];
+    recommendations: string[];
+}
+/**
+ * Security scanning manager
+ */
+export declare class SecurityScanningManager {
+    private scans;
+    private findings;
+    private reports;
+    private complianceChecks;
+    private postures;
+    private scanCounter;
+    private findingCounter;
+    private reportCounter;
+    private checkCounter;
+    private postureCounter;
+    /**
+     * Create security scan
+     */
+    createScan(scan: Omit<SecurityScan, 'id' | 'status' | 'findings'>): SecurityScan;
+    /**
+     * Create container image scan
+     */
+    createContainerScan(options: {
+        name: string;
+        imageUri: string;
+        region?: string;
+    }): SecurityScan;
+    /**
+     * Create Lambda function scan
+     */
+    createLambdaScan(options: {
+        name: string;
+        functionName: string;
+        region?: string;
+    }): SecurityScan;
+    /**
+     * Create secrets detection scan
+     */
+    createSecretsDetectionScan(options: {
+        name: string;
+        repositoryUrl: string;
+    }): SecurityScan;
+    /**
+     * Execute scan
+     */
+    executeScan(scanId: string): Promise<SecurityScan>;
+    /**
+     * Simulate findings (in production, this would call actual scanning tools)
+     */
+    private simulateFindings;
+    /**
+     * Create finding
+     */
+    createFinding(finding: Omit<SecurityFinding, 'id'>): SecurityFinding;
+    /**
+     * Suppress finding
+     */
+    suppressFinding(findingId: string, reason?: string): void;
+    /**
+     * Resolve finding
+     */
+    resolveFinding(findingId: string): void;
+    /**
+     * Generate vulnerability report
+     */
+    generateReport(options: {
+        scanId: string;
+        reportType: 'summary' | 'detailed' | 'executive';
+        format: 'json' | 'pdf' | 'html';
+    }): VulnerabilityReport;
+    /**
+     * Run compliance check
+     */
+    runComplianceCheck(options: {
+        framework: ComplianceFramework;
+        resourceType: string;
+        resourceId: string;
+    }): ComplianceCheck[];
+    /**
+     * Create compliance check
+     */
+    createComplianceCheck(check: Omit<ComplianceCheck, 'id'>): ComplianceCheck;
+    /**
+     * Assess security posture
+     */
+    assessSecurityPosture(options: {
+        accountId: string;
+        region: string;
+    }): SecurityPosture;
+    /**
+     * Get scan
+     */
+    getScan(id: string): SecurityScan | undefined;
+    /**
+     * List scans
+     */
+    listScans(): SecurityScan[];
+    /**
+     * Get open findings by severity
+     */
+    getOpenFindings(severity?: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW' | 'INFO'): SecurityFinding[];
+    /**
+     * Get compliance checks by status
+     */
+    getComplianceChecksByStatus(status: 'PASS' | 'FAIL' | 'WARNING' | 'NOT_APPLICABLE'): ComplianceCheck[];
+    /**
+     * List postures
+     */
+    listPostures(): SecurityPosture[];
+    /**
+     * Generate CloudFormation for ECR image scanning
+     */
+    generateECRScanCF(repositoryName: string): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global security scanning manager instance
+ */
+export declare const securityScanningManager: SecurityScanningManager;