@stacksjs/ts-cloud-core 0.1.3 → 0.1.7

package/dist/s3/index.d.ts

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

package/dist/schema/index.d.ts

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

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

@@ -0,0 +1,121 @@
+/**
+ * Global certificate manager instance
+ */
+export declare const certificateManager: CertificateManager;
+/**
+ * Certificate Lifecycle Management
+ * Automated certificate provisioning, renewal, and monitoring
+ */
+export declare 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 declare interface CertificateRenewal {
+  id: string
+  certificateArn: string
+  autoRenew: boolean
+  renewBeforeDays: number
+  lastRenewal?: Date
+  nextRenewal?: Date
+  renewalStatus?: 'success' | 'pending' | 'failed'
+}
+export declare interface CertificateValidation {
+  domainName: string
+  validationMethod: 'DNS' | 'EMAIL'
+  validationStatus: 'PENDING' | 'SUCCESS' | 'FAILED'
+  resourceRecords?: DnsRecord[]
+  validationEmails?: string[]
+}
+export declare interface DnsRecord {
+  name: string
+  type: 'CNAME' | 'A' | 'AAAA' | 'TXT'
+  value: string
+}
+export declare interface CertificateMonitor {
+  id: string
+  name: string
+  certificates: string[]
+  expirationThreshold: number
+  alertEnabled: boolean
+  snsTopicArn?: string
+}
+export declare interface CertificateAlert {
+  id: string
+  certificateArn: string
+  alertType: 'expiring_soon' | 'expired' | 'renewal_failed' | 'validation_failed'
+  severity: 'critical' | 'warning' | 'info'
+  message: string
+  timestamp: Date
+  acknowledged?: boolean
+}
+export type CertificateStatus = | 'PENDING_VALIDATION'
+  | 'ISSUED'
+  | 'INACTIVE'
+  | 'EXPIRED'
+  | 'VALIDATION_TIMED_OUT'
+  | 'REVOKED'
+  | 'FAILED'
+/**
+ * Certificate manager
+ */
+export declare class CertificateManager {
+  private certificates: Map<string, Certificate>;
+  private renewals: Map<string, CertificateRenewal>;
+  private validations: Map<string, CertificateValidation>;
+  private monitors: Map<string, CertificateMonitor>;
+  private alerts: Map<string, CertificateAlert>;
+  private certificateCounter: any;
+  private renewalCounter: any;
+  private validationCounter: any;
+  private monitorCounter: any;
+  private alertCounter: any;
+  requestCertificate(options: {
+    domainName: string
+    subjectAlternativeNames?: string[]
+    validationMethod?: 'DNS' | 'EMAIL'
+  }): Certificate;
+  requestWildcardCertificate(options: {
+    domainName: string
+    includeApex?: boolean
+  }): Certificate;
+  requestMultiDomainCertificate(options: {
+    primaryDomain: string
+    additionalDomains: string[]
+    validationMethod?: 'DNS' | 'EMAIL'
+  }): Certificate;
+  private createValidation(certificate: Certificate): CertificateValidation;
+  validateCertificate(certificateId: string): { success: boolean; message: string };
+  enableAutoRenewal(options: {
+    certificateArn: string
+    renewBeforeDays?: number
+  }): CertificateRenewal;
+  renewCertificate(renewalId: string): Promise<{ success: boolean; message: string }>;
+  createMonitor(monitor: Omit<CertificateMonitor, 'id'>): CertificateMonitor;
+  checkExpiration(): CertificateAlert[];
+  createAlert(alert: Omit<CertificateAlert, 'id' | 'timestamp' | 'acknowledged'>): CertificateAlert;
+  acknowledgeAlert(alertId: string): void;
+  getCertificate(id: string): Certificate | undefined;
+  listCertificates(): Certificate[];
+  getExpiringCertificates(days?: number): Certificate[];
+  getValidation(certificateId: string): CertificateValidation | undefined;
+  getRenewal(id: string): CertificateRenewal | undefined;
+  listRenewals(): CertificateRenewal[];
+  listAlerts(acknowledged?: boolean): CertificateAlert[];
+  generateCertificateCF(certificate: Certificate): any;
+  generateExpirationAlarmCF(options: {
+    alarmName: string
+    certificateArn: string
+    daysBeforeExpiration: number
+    snsTopicArn?: string
+  }): any;
+  clear(): void;
+}

package/dist/security/index.d.ts

@@ -0,0 +1,4 @@
+export * from './secrets-rotation';
+export * from './secrets-manager';
+export * from './certificate-manager';
+export * from './scanning';

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;
+}