@ts-cloud/core 0.2.3 → 0.2.4

package/dist/multi-region/cross-region.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Cross-Region Resource Management
+ * Handles references and dependencies between regions
+ */
+export interface CrossRegionReference {
+    sourceRegion: string;
+    targetRegion: string;
+    resourceType: string;
+    resourceId: string;
+    value: string;
+}
+export interface CrossRegionExport {
+    region: string;
+    exportName: string;
+    value: string;
+    description?: string;
+}
+/**
+ * Cross-region reference manager
+ */
+export declare class CrossRegionReferenceManager {
+    private references;
+    private exports;
+    /**
+     * Register a cross-region export
+     */
+    addExport(export_: CrossRegionExport): void;
+    /**
+     * Get export value from another region
+     */
+    getExport(region: string, exportName: string): string | undefined;
+    /**
+     * Create cross-region reference
+     */
+    createReference(sourceRegion: string, targetRegion: string, resourceType: string, resourceId: string): string;
+    /**
+     * Resolve cross-region reference
+     */
+    resolveReference(targetRegion: string, parameterName: string): Promise<string>;
+    /**
+     * Get all references for a region
+     */
+    getReferencesForRegion(region: string): CrossRegionReference[];
+    /**
+     * Clear all references
+     */
+    clear(): void;
+}
+/**
+ * Global resources that exist in one region but are accessible globally
+ */
+export interface GlobalResource {
+    type: 'cloudfront' | 'route53' | 'waf' | 'iam' | 's3-website';
+    id: string;
+    region: string;
+    arn: string;
+    endpoint?: string;
+}
+/**
+ * Global resource manager
+ */
+export declare class GlobalResourceManager {
+    private resources;
+    /**
+     * Register a global resource
+     */
+    register(resource: GlobalResource): void;
+    /**
+     * Get global resource
+     */
+    get(id: string): GlobalResource | undefined;
+    /**
+     * Get global resources by type
+     */
+    getByType(type: GlobalResource['type']): GlobalResource[];
+    /**
+     * Get CloudFront distributions
+     */
+    getCloudFrontDistributions(): GlobalResource[];
+    /**
+     * Get Route53 hosted zones
+     */
+    getRoute53HostedZones(): GlobalResource[];
+    /**
+     * Get WAF web ACLs
+     */
+    getWAFWebACLs(): GlobalResource[];
+    /**
+     * Remove global resource
+     */
+    remove(id: string): void;
+    /**
+     * Clear all global resources
+     */
+    clear(): void;
+}
+/**
+ * Region pairing for replication and failover
+ */
+export interface RegionPair {
+    primary: string;
+    secondary: string;
+    replicationConfig?: {
+        s3: boolean;
+        dynamodb: boolean;
+        rds: boolean;
+    };
+    failoverConfig?: {
+        automatic: boolean;
+        healthCheckInterval: number;
+        failoverThreshold: number;
+    };
+}
+/**
+ * Region pair manager
+ */
+export declare class RegionPairManager {
+    private pairs;
+    /**
+     * Add region pair
+     */
+    addPair(pair: RegionPair): void;
+    /**
+     * Get paired region
+     */
+    getPairedRegion(region: string): string | undefined;
+    /**
+     * Get all pairs
+     */
+    getAllPairs(): RegionPair[];
+    /**
+     * Get pairs with replication enabled
+     */
+    getReplicatedPairs(): RegionPair[];
+    /**
+     * Get pairs with failover enabled
+     */
+    getFailoverPairs(): RegionPair[];
+    /**
+     * Check if regions are paired
+     */
+    arePaired(region1: string, region2: string): boolean;
+    /**
+     * Clear all pairs
+     */
+    clear(): void;
+}
+/**
+ * Cross-region stack dependencies
+ */
+export interface StackDependency {
+    dependentStack: string;
+    dependentRegion: string;
+    dependsOnStack: string;
+    dependsOnRegion: string;
+    outputKey: string;
+}
+/**
+ * Stack dependency manager
+ */
+export declare class StackDependencyManager {
+    private dependencies;
+    /**
+     * Add stack dependency
+     */
+    addDependency(dependency: StackDependency): void;
+    /**
+     * Get dependencies for a stack
+     */
+    getDependencies(stackName: string, region: string): StackDependency[];
+    /**
+     * Get dependents of a stack
+     */
+    getDependents(stackName: string, region: string): StackDependency[];
+    /**
+     * Check if stack has dependencies
+     */
+    hasDependencies(stackName: string, region: string): boolean;
+    /**
+     * Get deployment order
+     */
+    getDeploymentOrder(stacks: Array<{
+        name: string;
+        region: string;
+    }>): Array<{
+        name: string;
+        region: string;
+    }>;
+    /**
+     * Detect circular dependencies
+     */
+    detectCircularDependencies(): boolean;
+    /**
+     * Clear all dependencies
+     */
+    clear(): void;
+}
+/**
+ * Global instances
+ */
+export declare const crossRegionReferenceManager: CrossRegionReferenceManager;
+export declare const globalResourceManager: GlobalResourceManager;
+export declare const regionPairManager: RegionPairManager;
+export declare const stackDependencyManager: StackDependencyManager;

package/dist/multi-region/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Multi-Region Deployment
+ * Deploy and manage infrastructure across multiple AWS regions
+ */
+export * from './manager';
+export * from './cross-region';
+export * from './regions';

package/dist/multi-region/manager.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Multi-Region Deployment Manager
+ * Deploys infrastructure across multiple AWS regions
+ */
+import type { CloudConfig } from '../types';
+export interface Region {
+    code: string;
+    name: string;
+    isPrimary?: boolean;
+    weight?: number;
+}
+export interface MultiRegionConfig {
+    regions: Region[];
+    globalResources?: {
+        route53?: boolean;
+        cloudfront?: boolean;
+        waf?: boolean;
+    };
+    replication?: {
+        s3?: boolean;
+        dynamodb?: boolean;
+        secrets?: boolean;
+    };
+    failover?: {
+        enabled: boolean;
+        healthCheckPath?: string;
+        failoverThreshold?: number;
+    };
+}
+export interface RegionDeployment {
+    region: string;
+    stackName: string;
+    status: 'pending' | 'deploying' | 'deployed' | 'failed' | 'rolling-back';
+    outputs?: Record<string, string>;
+    error?: string;
+    startTime?: Date;
+    endTime?: Date;
+}
+export interface MultiRegionDeployment {
+    id: string;
+    regions: RegionDeployment[];
+    globalResources?: Record<string, any>;
+    status: 'pending' | 'deploying' | 'deployed' | 'failed' | 'rolling-back';
+    startTime: Date;
+    endTime?: Date;
+}
+/**
+ * Multi-region deployment manager
+ */
+export declare class MultiRegionManager {
+    private deployments;
+    /**
+     * Deploy to multiple regions
+     */
+    deploy(config: CloudConfig, multiRegionConfig: MultiRegionConfig): Promise<MultiRegionDeployment>;
+    /**
+     * Deploy to a single region
+     */
+    private deployToRegion;
+    /**
+     * Deploy global resources (Route53, CloudFront, WAF)
+     */
+    private deployGlobalResources;
+    /**
+     * Deploy Route53 for multi-region routing
+     */
+    private deployRoute53;
+    /**
+     * Deploy CloudFront distribution
+     */
+    private deployCloudFront;
+    /**
+     * Deploy WAF
+     */
+    private deployWAF;
+    /**
+     * Set up cross-region replication
+     */
+    private setupReplication;
+    /**
+     * Set up S3 bucket replication
+     */
+    private setupS3Replication;
+    /**
+     * Set up DynamoDB global tables
+     */
+    private setupDynamoDBReplication;
+    /**
+     * Set up Secrets Manager replication
+     */
+    private setupSecretsReplication;
+    /**
+     * Set up failover configuration
+     */
+    private setupFailover;
+    /**
+     * Destroy multi-region deployment
+     */
+    destroy(deploymentId: string): Promise<void>;
+    /**
+     * Destroy global resources
+     */
+    private destroyGlobalResources;
+    /**
+     * Destroy stack in a single region
+     */
+    private destroyRegionStack;
+    /**
+     * Get deployment status
+     */
+    getDeployment(deploymentId: string): MultiRegionDeployment | undefined;
+    /**
+     * List all deployments
+     */
+    listDeployments(): MultiRegionDeployment[];
+    /**
+     * Get stack name for a region
+     */
+    private getStackName;
+    /**
+     * Create region-specific config
+     */
+    private createRegionConfig;
+    /**
+     * Deploy stack (placeholder)
+     */
+    private deployStack;
+    /**
+     * Generate deployment ID
+     */
+    private generateDeploymentId;
+}
+/**
+ * Global multi-region manager instance
+ */
+export declare const multiRegionManager: MultiRegionManager;

package/dist/multi-region/regions.d.ts

@@ -0,0 +1,98 @@
+/**
+ * AWS Region utilities
+ * Region selection, validation, and configuration
+ */
+export interface RegionInfo {
+    code: string;
+    name: string;
+    location: string;
+    launchYear: number;
+    availabilityZones: number;
+    localZones?: number;
+    wavelengthZones?: number;
+    services: {
+        compute: boolean;
+        storage: boolean;
+        database: boolean;
+        networking: boolean;
+        ml: boolean;
+        analytics: boolean;
+    };
+    pricing: {
+        tier: 'standard' | 'reduced' | 'premium';
+        multiplier: number;
+    };
+    compliance: string[];
+}
+/**
+ * AWS Region database
+ */
+export declare const AWS_REGIONS: RegionInfo[];
+/**
+ * Get region by code
+ */
+export declare function getRegion(code: string): RegionInfo | undefined;
+/**
+ * Get all regions
+ */
+export declare function getAllRegions(): RegionInfo[];
+/**
+ * Get regions by location
+ */
+export declare function getRegionsByLocation(location: string): RegionInfo[];
+/**
+ * Get regions with specific compliance
+ */
+export declare function getRegionsByCompliance(compliance: string): RegionInfo[];
+/**
+ * Get regions by pricing tier
+ */
+export declare function getRegionsByPricingTier(tier: 'standard' | 'reduced' | 'premium'): RegionInfo[];
+/**
+ * Validate region code
+ */
+export declare function isValidRegion(code: string): boolean;
+/**
+ * Get closest region to user location
+ */
+export declare function getClosestRegion(userLocation: {
+    continent?: string;
+    country?: string;
+}): RegionInfo;
+/**
+ * Suggest regions based on requirements
+ */
+export interface RegionRequirements {
+    compliance?: string[];
+    pricingSensitive?: boolean;
+    lowLatency?: boolean;
+    userLocations?: string[];
+    requiredServices?: Array<keyof RegionInfo['services']>;
+}
+export declare function suggestRegions(requirements: RegionRequirements): RegionInfo[];
+/**
+ * Calculate region pairs for failover
+ */
+export interface RegionPairSuggestion {
+    primary: RegionInfo;
+    secondary: RegionInfo;
+    distance: number;
+    sameContinent: boolean;
+}
+export declare function suggestRegionPairs(primaryRegion: string): RegionPairSuggestion[];
+/**
+ * Format region for display
+ */
+export declare function formatRegion(region: RegionInfo): string;
+/**
+ * Format region list for display
+ */
+export declare function formatRegionList(regions: RegionInfo[]): string;
+/**
+ * Get region statistics
+ */
+export declare function getRegionStats(): {
+    total: number;
+    byContinent: Record<string, number>;
+    byPricingTier: Record<string, number>;
+};

package/dist/network-security/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Network Security - WAF, Shield, security groups, NACLs
+ */
+export interface WAFRule {
+    id: string;
+    name: string;
+    priority: number;
+    action: 'allow' | 'block' | 'count';
+    conditions: string[];
+}
+export interface ShieldProtection {
+    id: string;
+    resourceArn: string;
+    protectionType: 'standard' | 'advanced';
+}
+export interface SecurityGroup {
+    id: string;
+    name: string;
+    vpcId: string;
+    rules: Array<{
+        protocol: string;
+        port: number;
+        source: string;
+    }>;
+}
+export interface NACL {
+    id: string;
+    vpcId: string;
+    rules: Array<{
+        ruleNumber: number;
+        protocol: string;
+        action: 'allow' | 'deny';
+    }>;
+}
+export declare class NetworkSecurityManager {
+    private wafRules;
+    private shieldProtections;
+    private securityGroups;
+    private nacls;
+    private counter;
+    createWAFRule(name: string, priority: number, action: 'allow' | 'block' | 'count', conditions: string[]): WAFRule;
+    enableShield(resourceArn: string, protectionType?: 'standard' | 'advanced'): ShieldProtection;
+    createSecurityGroup(name: string, vpcId: string, rules: Array<{
+        protocol: string;
+        port: number;
+        source: string;
+    }>): SecurityGroup;
+    createNACL(vpcId: string, rules: Array<{
+        ruleNumber: number;
+        protocol: string;
+        action: 'allow' | 'deny';
+    }>): NACL;
+    clear(): void;
+}
+export declare const networkSecurityManager: NetworkSecurityManager;

package/dist/observability/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Observability Module
+ * Comprehensive monitoring, logging, and tracing for cloud applications
+ */
+export * from './xray';
+export * from './metrics';
+export * from './logs';
+export * from './synthetics';