@stacksjs/ts-cloud 0.2.3 → 0.2.5

package/dist/aws/elbv2.d.ts

@@ -0,0 +1,389 @@
+/**
+ * AWS Elastic Load Balancing V2 (ELBv2) Operations
+ * Direct API calls without AWS CLI dependency
+ *
+ * Supports Application Load Balancers (ALB), Network Load Balancers (NLB),
+ * and Gateway Load Balancers (GWLB)
+ */
+export interface LoadBalancer {
+    LoadBalancerArn?: string;
+    DNSName?: string;
+    CanonicalHostedZoneId?: string;
+    CreatedTime?: string;
+    LoadBalancerName?: string;
+    Scheme?: 'internet-facing' | 'internal';
+    VpcId?: string;
+    State?: {
+        Code?: 'active' | 'provisioning' | 'active_impaired' | 'failed';
+        Reason?: string;
+    };
+    Type?: 'application' | 'network' | 'gateway';
+    AvailabilityZones?: AvailabilityZone[];
+    SecurityGroups?: string[];
+    IpAddressType?: 'ipv4' | 'dualstack';
+}
+export interface AvailabilityZone {
+    ZoneName?: string;
+    SubnetId?: string;
+    OutpostId?: string;
+    LoadBalancerAddresses?: LoadBalancerAddress[];
+}
+export interface LoadBalancerAddress {
+    IpAddress?: string;
+    AllocationId?: string;
+    PrivateIPv4Address?: string;
+    IPv6Address?: string;
+}
+export interface TargetGroup {
+    TargetGroupArn?: string;
+    TargetGroupName?: string;
+    Protocol?: string;
+    Port?: number;
+    VpcId?: string;
+    HealthCheckProtocol?: string;
+    HealthCheckPort?: string;
+    HealthCheckEnabled?: boolean;
+    HealthCheckIntervalSeconds?: number;
+    HealthCheckTimeoutSeconds?: number;
+    HealthyThresholdCount?: number;
+    UnhealthyThresholdCount?: number;
+    HealthCheckPath?: string;
+    Matcher?: {
+        HttpCode?: string;
+        GrpcCode?: string;
+    };
+    LoadBalancerArns?: string[];
+    TargetType?: 'instance' | 'ip' | 'lambda' | 'alb';
+    ProtocolVersion?: string;
+    IpAddressType?: 'ipv4' | 'ipv6';
+}
+export interface Listener {
+    ListenerArn?: string;
+    LoadBalancerArn?: string;
+    Port?: number;
+    Protocol?: string;
+    Certificates?: Certificate[];
+    SslPolicy?: string;
+    DefaultActions?: Action[];
+    AlpnPolicy?: string[];
+}
+export interface Certificate {
+    CertificateArn?: string;
+    IsDefault?: boolean;
+}
+export interface Action {
+    Type?: 'forward' | 'redirect' | 'fixed-response' | 'authenticate-oidc' | 'authenticate-cognito';
+    TargetGroupArn?: string;
+    Order?: number;
+    RedirectConfig?: {
+        Protocol?: string;
+        Port?: string;
+        Host?: string;
+        Path?: string;
+        Query?: string;
+        StatusCode?: 'HTTP_301' | 'HTTP_302';
+    };
+    FixedResponseConfig?: {
+        MessageBody?: string;
+        StatusCode?: string;
+        ContentType?: string;
+    };
+    ForwardConfig?: {
+        TargetGroups?: Array<{
+            TargetGroupArn?: string;
+            Weight?: number;
+        }>;
+        TargetGroupStickinessConfig?: {
+            Enabled?: boolean;
+            DurationSeconds?: number;
+        };
+    };
+}
+export interface Rule {
+    RuleArn?: string;
+    Priority?: string;
+    Conditions?: Condition[];
+    Actions?: Action[];
+    IsDefault?: boolean;
+}
+export interface Condition {
+    Field?: string;
+    Values?: string[];
+    HostHeaderConfig?: {
+        Values?: string[];
+    };
+    PathPatternConfig?: {
+        Values?: string[];
+    };
+    HttpHeaderConfig?: {
+        HttpHeaderName?: string;
+        Values?: string[];
+    };
+    QueryStringConfig?: {
+        Values?: Array<{
+            Key?: string;
+            Value?: string;
+        }>;
+    };
+    HttpRequestMethodConfig?: {
+        Values?: string[];
+    };
+    SourceIpConfig?: {
+        Values?: string[];
+    };
+}
+export interface TargetHealthDescription {
+    Target?: {
+        Id?: string;
+        Port?: number;
+        AvailabilityZone?: string;
+    };
+    HealthCheckPort?: string;
+    TargetHealth?: {
+        State?: 'initial' | 'healthy' | 'unhealthy' | 'unused' | 'draining' | 'unavailable';
+        Reason?: string;
+        Description?: string;
+    };
+}
+/**
+ * ELBv2 client for managing Application, Network, and Gateway Load Balancers
+ */
+export declare class ELBv2Client {
+    private client;
+    private region;
+    constructor(region?: string);
+    /**
+     * Describe load balancers
+     */
+    describeLoadBalancers(options?: {
+        LoadBalancerArns?: string[];
+        Names?: string[];
+        Marker?: string;
+        PageSize?: number;
+    }): Promise<{
+        LoadBalancers?: LoadBalancer[];
+        NextMarker?: string;
+    }>;
+    /**
+     * Describe target groups
+     */
+    describeTargetGroups(options?: {
+        LoadBalancerArn?: string;
+        TargetGroupArns?: string[];
+        Names?: string[];
+        Marker?: string;
+        PageSize?: number;
+    }): Promise<{
+        TargetGroups?: TargetGroup[];
+        NextMarker?: string;
+    }>;
+    /**
+     * Describe target health
+     */
+    describeTargetHealth(options: {
+        TargetGroupArn: string;
+        Targets?: Array<{
+            Id: string;
+            Port?: number;
+            AvailabilityZone?: string;
+        }>;
+    }): Promise<{
+        TargetHealthDescriptions?: TargetHealthDescription[];
+    }>;
+    /**
+     * Describe listeners
+     */
+    describeListeners(options?: {
+        LoadBalancerArn?: string;
+        ListenerArns?: string[];
+        Marker?: string;
+        PageSize?: number;
+    }): Promise<{
+        Listeners?: Listener[];
+        NextMarker?: string;
+    }>;
+    /**
+     * Describe rules for a listener
+     */
+    describeRules(options?: {
+        ListenerArn?: string;
+        RuleArns?: string[];
+        Marker?: string;
+        PageSize?: number;
+    }): Promise<{
+        Rules?: Rule[];
+        NextMarker?: string;
+    }>;
+    /**
+     * Describe load balancer attributes
+     */
+    describeLoadBalancerAttributes(loadBalancerArn: string): Promise<{
+        Attributes?: Array<{
+            Key: string;
+            Value: string;
+        }>;
+    }>;
+    /**
+     * Describe target group attributes
+     */
+    describeTargetGroupAttributes(targetGroupArn: string): Promise<{
+        Attributes?: Array<{
+            Key: string;
+            Value: string;
+        }>;
+    }>;
+    /**
+     * Create a load balancer
+     */
+    createLoadBalancer(options: {
+        Name: string;
+        Subnets?: string[];
+        SubnetMappings?: Array<{
+            SubnetId: string;
+            AllocationId?: string;
+            PrivateIPv4Address?: string;
+            IPv6Address?: string;
+        }>;
+        SecurityGroups?: string[];
+        Scheme?: 'internet-facing' | 'internal';
+        Type?: 'application' | 'network' | 'gateway';
+        IpAddressType?: 'ipv4' | 'dualstack';
+        Tags?: Array<{
+            Key: string;
+            Value: string;
+        }>;
+    }): Promise<{
+        LoadBalancers?: LoadBalancer[];
+    }>;
+    /**
+     * Delete a load balancer
+     */
+    deleteLoadBalancer(loadBalancerArn: string): Promise<void>;
+    /**
+     * Create a target group
+     */
+    createTargetGroup(options: {
+        Name: string;
+        Protocol?: string;
+        ProtocolVersion?: string;
+        Port?: number;
+        VpcId?: string;
+        HealthCheckProtocol?: string;
+        HealthCheckPort?: string;
+        HealthCheckEnabled?: boolean;
+        HealthCheckPath?: string;
+        HealthCheckIntervalSeconds?: number;
+        HealthCheckTimeoutSeconds?: number;
+        HealthyThresholdCount?: number;
+        UnhealthyThresholdCount?: number;
+        Matcher?: {
+            HttpCode?: string;
+            GrpcCode?: string;
+        };
+        TargetType?: 'instance' | 'ip' | 'lambda' | 'alb';
+        Tags?: Array<{
+            Key: string;
+            Value: string;
+        }>;
+        IpAddressType?: 'ipv4' | 'ipv6';
+    }): Promise<{
+        TargetGroups?: TargetGroup[];
+    }>;
+    /**
+     * Delete a target group
+     */
+    deleteTargetGroup(targetGroupArn: string): Promise<void>;
+    /**
+     * Register targets with a target group
+     */
+    registerTargets(options: {
+        TargetGroupArn: string;
+        Targets: Array<{
+            Id: string;
+            Port?: number;
+            AvailabilityZone?: string;
+        }>;
+    }): Promise<void>;
+    /**
+     * Deregister targets from a target group
+     */
+    deregisterTargets(options: {
+        TargetGroupArn: string;
+        Targets: Array<{
+            Id: string;
+            Port?: number;
+            AvailabilityZone?: string;
+        }>;
+    }): Promise<void>;
+    /**
+     * Create a listener
+     */
+    createListener(options: {
+        LoadBalancerArn: string;
+        Protocol?: string;
+        Port: number;
+        SslPolicy?: string;
+        Certificates?: Array<{
+            CertificateArn: string;
+        }>;
+        DefaultActions: Array<{
+            Type: 'forward' | 'redirect' | 'fixed-response';
+            TargetGroupArn?: string;
+            Order?: number;
+            RedirectConfig?: {
+                Protocol?: string;
+                Port?: string;
+                Host?: string;
+                Path?: string;
+                Query?: string;
+                StatusCode: 'HTTP_301' | 'HTTP_302';
+            };
+            FixedResponseConfig?: {
+                MessageBody?: string;
+                StatusCode: string;
+                ContentType?: string;
+            };
+        }>;
+        AlpnPolicy?: string[];
+        Tags?: Array<{
+            Key: string;
+            Value: string;
+        }>;
+    }): Promise<{
+        Listeners?: Listener[];
+    }>;
+    /**
+     * Delete a listener
+     */
+    deleteListener(listenerArn: string): Promise<void>;
+    /**
+     * Modify listener
+     */
+    modifyListener(options: {
+        ListenerArn: string;
+        Port?: number;
+        Protocol?: string;
+        SslPolicy?: string;
+        Certificates?: Array<{
+            CertificateArn: string;
+        }>;
+        DefaultActions?: Action[];
+        AlpnPolicy?: string[];
+    }): Promise<{
+        Listeners?: Listener[];
+    }>;
+    /**
+     * Build form URL encoded body for ELBv2 API
+     */
+    private buildFormBody;
+    /**
+     * Normalize the parsed XML result from AWS API
+     * The client parses XML to JSON, so we need to extract the result
+     */
+    private normalizeResult;
+    /**
+     * Normalize arrays in the response
+     * AWS XML parsing sometimes returns single items as objects instead of arrays
+     */
+    private normalizeArrays;
+}

package/dist/aws/email.d.ts

@@ -0,0 +1,260 @@
+/**
+ * AWS Email Module
+ * High-level email operations for both serverless and server deployments
+ *
+ * This module provides:
+ * - Email sending via SES
+ * - Email receiving setup (receipt rules, S3 storage)
+ * - Domain verification and DKIM setup
+ * - SMTP credential management for client email apps
+ */
+export interface EmailConfig {
+    domain: string;
+    region?: string;
+    mailboxes?: string[];
+    storage?: {
+        bucket?: string;
+        prefix?: string;
+        retentionDays?: number;
+    };
+    smtp?: {
+        enabled?: boolean;
+        username?: string;
+    };
+}
+export interface EmailSetupResult {
+    domainVerified: boolean;
+    dkimStatus: string;
+    dkimTokens?: string[];
+    mailFromStatus?: string;
+    receiptRuleSet?: string;
+    storageBucket?: string;
+    smtpCredentials?: {
+        username: string;
+        server: string;
+        port: number;
+    };
+}
+export interface SendEmailOptions {
+    from?: string;
+    fromName?: string;
+    to: string | string[];
+    cc?: string | string[];
+    bcc?: string | string[];
+    subject: string;
+    text?: string;
+    html?: string;
+    replyTo?: string | string[];
+    attachments?: Array<{
+        filename: string;
+        content: string;
+        contentType?: string;
+    }>;
+}
+export interface EmailDeploymentConfig {
+    domain: string;
+    accountId: string;
+    region?: string;
+    appName: string;
+    environment: string;
+    mailboxes?: string[];
+    catchAll?: boolean;
+    storage?: {
+        bucketName?: string;
+        prefix?: string;
+    };
+    notifications?: {
+        bounces?: boolean;
+        complaints?: boolean;
+        newEmail?: boolean;
+    };
+}
+/**
+ * High-level Email client for serverless and server deployments
+ */
+export declare class EmailClient {
+    private ses;
+    private s3;
+    private iam;
+    private route53;
+    private region;
+    private domain?;
+    private defaultFrom?;
+    constructor(options?: {
+        region?: string;
+        domain?: string;
+        defaultFrom?: string;
+    });
+    /**
+     * Send an email
+     */
+    send(options: SendEmailOptions): Promise<{
+        messageId: string;
+    }>;
+    /**
+     * Send a templated email
+     */
+    sendTemplate(options: {
+        from?: string;
+        fromName?: string;
+        to: string | string[];
+        templateName: string;
+        templateData: Record<string, any>;
+        replyTo?: string | string[];
+    }): Promise<{
+        messageId: string;
+    }>;
+    /**
+     * Send bulk emails using a template
+     */
+    sendBulk(options: {
+        from?: string;
+        templateName: string;
+        defaultTemplateData: Record<string, any>;
+        recipients: Array<{
+            to: string | string[];
+            templateData?: Record<string, any>;
+        }>;
+    }): Promise<{
+        results: Array<{
+            status: string;
+            messageId?: string;
+            error?: string;
+        }>;
+    }>;
+    /**
+     * Set up email for a domain (creates identity, DKIM, etc.)
+     */
+    setupDomain(domain: string): Promise<EmailSetupResult>;
+    /**
+     * Get DNS records needed for email verification
+     */
+    getDnsRecords(domain: string): Promise<Array<{
+        type: string;
+        name: string;
+        value: string;
+        priority?: number;
+        ttl?: number;
+    }>>;
+    /**
+     * Check if domain is fully verified and ready to send
+     */
+    isDomainReady(domain: string): Promise<boolean>;
+    /**
+     * Set up email receiving for a domain
+     */
+    setupReceiving(config: {
+        domain: string;
+        ruleSetName: string;
+        ruleName: string;
+        bucketName: string;
+        prefix?: string;
+        accountId: string;
+        recipients?: string[];
+        scanEnabled?: boolean;
+        lambdaArn?: string;
+    }): Promise<void>;
+    /**
+     * Get incoming emails from S3 bucket
+     */
+    getIncomingEmails(options: {
+        bucket: string;
+        prefix?: string;
+        maxResults?: number;
+    }): Promise<Array<{
+        key: string;
+        lastModified: string;
+        size: number;
+    }>>;
+    /**
+     * Read an email from S3
+     */
+    readEmail(options: {
+        bucket: string;
+        key: string;
+    }): Promise<string>;
+    /**
+     * Create SMTP credentials for sending via email clients
+     * Note: These use IAM users and SES SMTP interface
+     */
+    createSmtpCredentials(options: {
+        username: string;
+        domain: string;
+    }): Promise<{
+        username: string;
+        password: string;
+        server: string;
+        port: number;
+    }>;
+    /**
+     * Derive SMTP password from AWS secret access key
+     * Based on AWS documentation for SES SMTP credentials
+     */
+    private deriveSmtpPassword;
+    /**
+     * Create an email template
+     */
+    createTemplate(options: {
+        name: string;
+        subject: string;
+        text?: string;
+        html?: string;
+    }): Promise<void>;
+    /**
+     * Get an email template
+     */
+    getTemplate(name: string): Promise<{
+        name: string;
+        subject?: string;
+        text?: string;
+        html?: string;
+    } | null>;
+    /**
+     * Delete an email template
+     */
+    deleteTemplate(name: string): Promise<void>;
+    /**
+     * List all email templates
+     */
+    listTemplates(): Promise<Array<{
+        name: string;
+        createdAt?: string;
+    }>>;
+    /**
+     * Deploy full email infrastructure for an application
+     */
+    deploy(config: EmailDeploymentConfig): Promise<{
+        success: boolean;
+        domainVerified: boolean;
+        dkimStatus: string;
+        receiptRuleSet: string;
+        storageBucket: string;
+        dnsRecords: Array<{
+            type: string;
+            name: string;
+            value: string;
+        }>;
+    }>;
+    /**
+     * Undeploy email infrastructure
+     */
+    undeploy(config: {
+        appName: string;
+        environment: string;
+        domain: string;
+        deleteBucket?: boolean;
+    }): Promise<void>;
+    /**
+     * Get sending statistics
+     */
+    getSendingStats(): Promise<{
+        sentLast24Hours: number;
+        maxSendRate: number;
+        max24HourSend: number;
+    }>;
+    /**
+     * Build a raw MIME email with attachments
+     */
+    private buildRawEmail;
+}
+export declare const email: EmailClient;