@stacksjs/ts-cloud 0.2.3 → 0.2.5

package/dist/aws/acm.d.ts

@@ -0,0 +1,215 @@
+/**
+ * ACM (AWS Certificate Manager) Client
+ * For requesting and managing SSL/TLS certificates
+ */
+export interface CertificateDetail {
+    CertificateArn: string;
+    DomainName: string;
+    SubjectAlternativeNames?: string[];
+    Status: 'PENDING_VALIDATION' | 'ISSUED' | 'INACTIVE' | 'EXPIRED' | 'VALIDATION_TIMED_OUT' | 'REVOKED' | 'FAILED';
+    Type?: 'IMPORTED' | 'AMAZON_ISSUED' | 'PRIVATE';
+    DomainValidationOptions?: {
+        DomainName: string;
+        ValidationDomain?: string;
+        ValidationStatus?: 'PENDING_VALIDATION' | 'SUCCESS' | 'FAILED';
+        ResourceRecord?: {
+            Name: string;
+            Type: string;
+            Value: string;
+        };
+        ValidationMethod?: 'EMAIL' | 'DNS';
+    }[];
+    CreatedAt?: string;
+    IssuedAt?: string;
+    NotBefore?: string;
+    NotAfter?: string;
+}
+export declare class ACMClient {
+    private client;
+    private region;
+    constructor(region?: string);
+    /**
+     * Request a new certificate
+     */
+    requestCertificate(params: {
+        DomainName: string;
+        SubjectAlternativeNames?: string[];
+        ValidationMethod?: 'EMAIL' | 'DNS';
+    }): Promise<{
+        CertificateArn: string;
+    }>;
+    /**
+     * Describe a certificate to get its details and validation options
+     */
+    describeCertificate(params: {
+        CertificateArn: string;
+    }): Promise<CertificateDetail>;
+    /**
+     * List certificates
+     */
+    listCertificates(params?: {
+        CertificateStatuses?: ('PENDING_VALIDATION' | 'ISSUED' | 'INACTIVE' | 'EXPIRED' | 'VALIDATION_TIMED_OUT' | 'REVOKED' | 'FAILED')[];
+        MaxItems?: number;
+        NextToken?: string;
+    }): Promise<{
+        CertificateSummaryList: {
+            CertificateArn: string;
+            DomainName: string;
+        }[];
+        NextToken?: string;
+    }>;
+    /**
+     * Delete a certificate
+     */
+    deleteCertificate(params: {
+        CertificateArn: string;
+    }): Promise<void>;
+    /**
+     * Get certificate tags
+     */
+    listTagsForCertificate(params: {
+        CertificateArn: string;
+    }): Promise<{
+        Tags: Array<{
+            Key: string;
+            Value?: string;
+        }>;
+    }>;
+    /**
+     * Add tags to a certificate
+     */
+    addTagsToCertificate(params: {
+        CertificateArn: string;
+        Tags: Array<{
+            Key: string;
+            Value?: string;
+        }>;
+    }): Promise<void>;
+    /**
+     * Resend validation email
+     */
+    resendValidationEmail(params: {
+        CertificateArn: string;
+        Domain: string;
+        ValidationDomain: string;
+    }): Promise<void>;
+    /**
+     * Find certificate by domain name
+     */
+    findCertificateByDomain(domainName: string): Promise<CertificateDetail | null>;
+    /**
+     * Wait for certificate to be issued
+     */
+    waitForCertificateValidation(certificateArn: string, maxAttempts?: number, delayMs?: number): Promise<CertificateDetail | null>;
+    /**
+     * Get DNS validation records for a certificate
+     */
+    getDnsValidationRecords(certificateArn: string): Promise<Array<{
+        domainName: string;
+        recordName: string;
+        recordType: string;
+        recordValue: string;
+    }>>;
+    /**
+     * Request certificate for a domain with common SANs
+     * Automatically includes www and wildcard
+     */
+    requestCertificateWithSans(params: {
+        DomainName: string;
+        IncludeWww?: boolean;
+        IncludeWildcard?: boolean;
+        AdditionalSans?: string[];
+    }): Promise<{
+        CertificateArn: string;
+    }>;
+    /**
+     * Check if certificate is valid for a given domain
+     */
+    isCertificateValidForDomain(certificateArn: string, domainName: string): Promise<boolean>;
+}
+import type { DnsProviderConfig } from '../dns/types';
+/**
+ * Helper class for ACM DNS validation with Route53 integration
+ * @deprecated Use UnifiedDnsValidator from 'ts-cloud/dns' for multi-provider support (Route53, Porkbun, GoDaddy)
+ */
+export declare class ACMDnsValidator {
+    private acm;
+    private route53;
+    private dnsProvider?;
+    /**
+     * Create ACM DNS validator
+     * @param region - AWS region for ACM (default: us-east-1)
+     * @param dnsProviderConfig - Optional external DNS provider config (Porkbun, GoDaddy)
+     */
+    constructor(region?: string, dnsProviderConfig?: DnsProviderConfig);
+    /**
+     * Request certificate and automatically create DNS validation records
+     * @param params.domainName - Primary domain name for the certificate
+     * @param params.hostedZoneId - Route53 hosted zone ID (required if no external DNS provider configured)
+     * @param params.subjectAlternativeNames - Additional domain names (SANs)
+     * @param params.waitForValidation - Wait for certificate to be issued
+     * @param params.maxWaitMinutes - Maximum wait time in minutes
+     */
+    requestAndValidate(params: {
+        domainName: string;
+        hostedZoneId?: string;
+        subjectAlternativeNames?: string[];
+        waitForValidation?: boolean;
+        maxWaitMinutes?: number;
+    }): Promise<{
+        certificateArn: string;
+        validationRecords: Array<{
+            domainName: string;
+            recordName: string;
+            recordValue: string;
+        }>;
+    }>;
+    /**
+     * Wait for validation options to become available
+     */
+    private waitForValidationOptions;
+    /**
+     * Create validation records for an existing certificate
+     * Uses external DNS provider if configured, otherwise Route53
+     */
+    createValidationRecords(params: {
+        certificateArn: string;
+        hostedZoneId?: string;
+        domain?: string;
+    }): Promise<Array<{
+        domainName: string;
+        recordName: string;
+        recordValue: string;
+        changeId?: string;
+    }>>;
+    /**
+     * Delete validation records after certificate is issued
+     * Uses external DNS provider if configured, otherwise Route53
+     */
+    deleteValidationRecords(params: {
+        certificateArn: string;
+        hostedZoneId?: string;
+        domain?: string;
+    }): Promise<void>;
+    /**
+     * Find or create a certificate for a domain
+     * Uses external DNS provider if configured, otherwise Route53
+     */
+    findOrCreateCertificate(params: {
+        domainName: string;
+        hostedZoneId?: string;
+        subjectAlternativeNames?: string[];
+        waitForValidation?: boolean;
+    }): Promise<{
+        certificateArn: string;
+        isNew: boolean;
+    }>;
+    /**
+     * Check if using external DNS provider
+     */
+    hasExternalDnsProvider(): boolean;
+    /**
+     * Get the DNS provider name if using external provider
+     */
+    getDnsProviderName(): string;
+}

package/dist/aws/application-autoscaling.d.ts

@@ -0,0 +1,345 @@
+/**
+ * AWS Application Auto Scaling Client
+ * Supports auto-scaling for ECS services, DynamoDB tables, and other AWS resources
+ * Direct API calls without AWS CLI dependency
+ */
+export type ScalableDimension = 'ecs:service:DesiredCount' | 'dynamodb:table:ReadCapacityUnits' | 'dynamodb:table:WriteCapacityUnits' | 'dynamodb:index:ReadCapacityUnits' | 'dynamodb:index:WriteCapacityUnits' | 'rds:cluster:ReadReplicaCount' | 'lambda:function:ProvisionedConcurrency' | 'elasticache:replication-group:NodeGroups' | 'elasticache:replication-group:Replicas';
+export type ServiceNamespace = 'ecs' | 'dynamodb' | 'rds' | 'lambda' | 'elasticache' | 'custom-resource' | 'comprehend' | 'kafka' | 'sagemaker';
+export type MetricType = 'ECSServiceAverageCPUUtilization' | 'ECSServiceAverageMemoryUtilization' | 'ALBRequestCountPerTarget' | 'DynamoDBReadCapacityUtilization' | 'DynamoDBWriteCapacityUtilization' | 'RDSReaderAverageCPUUtilization' | 'RDSReaderAverageDatabaseConnections' | 'EC2SpotFleetRequestAverageCPUUtilization' | 'EC2SpotFleetRequestAverageNetworkIn' | 'EC2SpotFleetRequestAverageNetworkOut' | 'SageMakerVariantInvocationsPerInstance' | 'SageMakerVariantProvisionedConcurrencyUtilization' | 'ElastiCachePrimaryEngineCPUUtilization' | 'ElastiCacheReplicaEngineCPUUtilization' | 'ElastiCacheDatabaseMemoryUsageCountedForEvictPercentage' | 'LambdaProvisionedConcurrencyUtilization' | 'CassandraReadCapacityUtilization' | 'CassandraWriteCapacityUtilization';
+export interface ScalableTarget {
+    ServiceNamespace: ServiceNamespace;
+    ResourceId: string;
+    ScalableDimension: ScalableDimension;
+    MinCapacity: number;
+    MaxCapacity: number;
+    RoleARN?: string;
+    CreationTime?: string;
+    SuspendedState?: {
+        DynamicScalingInSuspended?: boolean;
+        DynamicScalingOutSuspended?: boolean;
+        ScheduledScalingSuspended?: boolean;
+    };
+}
+export interface ScalingPolicy {
+    PolicyARN?: string;
+    PolicyName: string;
+    ServiceNamespace: ServiceNamespace;
+    ResourceId: string;
+    ScalableDimension: ScalableDimension;
+    PolicyType: 'TargetTrackingScaling' | 'StepScaling';
+    StepScalingPolicyConfiguration?: StepScalingPolicyConfiguration;
+    TargetTrackingScalingPolicyConfiguration?: TargetTrackingScalingPolicyConfiguration;
+    Alarms?: Array<{
+        AlarmName: string;
+        AlarmARN: string;
+    }>;
+    CreationTime?: string;
+}
+export interface StepScalingPolicyConfiguration {
+    AdjustmentType: 'ChangeInCapacity' | 'PercentChangeInCapacity' | 'ExactCapacity';
+    StepAdjustments: Array<{
+        MetricIntervalLowerBound?: number;
+        MetricIntervalUpperBound?: number;
+        ScalingAdjustment: number;
+    }>;
+    MinAdjustmentMagnitude?: number;
+    Cooldown?: number;
+    MetricAggregationType?: 'Average' | 'Minimum' | 'Maximum';
+}
+export interface TargetTrackingScalingPolicyConfiguration {
+    TargetValue: number;
+    PredefinedMetricSpecification?: {
+        PredefinedMetricType: MetricType;
+        ResourceLabel?: string;
+    };
+    CustomizedMetricSpecification?: {
+        MetricName: string;
+        Namespace: string;
+        Statistic: 'Average' | 'Minimum' | 'Maximum' | 'SampleCount' | 'Sum';
+        Unit?: string;
+        Dimensions?: Array<{
+            Name: string;
+            Value: string;
+        }>;
+    };
+    ScaleOutCooldown?: number;
+    ScaleInCooldown?: number;
+    DisableScaleIn?: boolean;
+}
+export interface ScheduledAction {
+    ScheduledActionName: string;
+    ScheduledActionARN?: string;
+    ServiceNamespace: ServiceNamespace;
+    Schedule: string;
+    Timezone?: string;
+    ResourceId: string;
+    ScalableDimension: ScalableDimension;
+    StartTime?: string;
+    EndTime?: string;
+    ScalableTargetAction?: {
+        MinCapacity?: number;
+        MaxCapacity?: number;
+    };
+    CreationTime?: string;
+}
+/**
+ * Application Auto Scaling client for ECS, DynamoDB, and other services
+ */
+export declare class ApplicationAutoScalingClient {
+    private client;
+    private region;
+    constructor(region?: string);
+    /**
+     * Register a scalable target
+     * This must be done before creating scaling policies
+     */
+    registerScalableTarget(options: {
+        serviceNamespace: ServiceNamespace;
+        resourceId: string;
+        scalableDimension: ScalableDimension;
+        minCapacity: number;
+        maxCapacity: number;
+        roleARN?: string;
+        suspendedState?: {
+            dynamicScalingInSuspended?: boolean;
+            dynamicScalingOutSuspended?: boolean;
+            scheduledScalingSuspended?: boolean;
+        };
+    }): Promise<void>;
+    /**
+     * Describe scalable targets
+     */
+    describeScalableTargets(options: {
+        serviceNamespace: ServiceNamespace;
+        resourceIds?: string[];
+        scalableDimension?: ScalableDimension;
+        maxResults?: number;
+        nextToken?: string;
+    }): Promise<{
+        ScalableTargets: ScalableTarget[];
+        NextToken?: string;
+    }>;
+    /**
+     * Deregister a scalable target
+     */
+    deregisterScalableTarget(options: {
+        serviceNamespace: ServiceNamespace;
+        resourceId: string;
+        scalableDimension: ScalableDimension;
+    }): Promise<void>;
+    /**
+     * Put a scaling policy (create or update)
+     */
+    putScalingPolicy(options: {
+        policyName: string;
+        serviceNamespace: ServiceNamespace;
+        resourceId: string;
+        scalableDimension: ScalableDimension;
+        policyType: 'TargetTrackingScaling' | 'StepScaling';
+        targetTrackingScalingPolicyConfiguration?: TargetTrackingScalingPolicyConfiguration;
+        stepScalingPolicyConfiguration?: StepScalingPolicyConfiguration;
+    }): Promise<{
+        PolicyARN: string;
+        Alarms: Array<{
+            AlarmName: string;
+            AlarmARN: string;
+        }>;
+    }>;
+    /**
+     * Describe scaling policies
+     */
+    describeScalingPolicies(options: {
+        serviceNamespace: ServiceNamespace;
+        policyNames?: string[];
+        resourceId?: string;
+        scalableDimension?: ScalableDimension;
+        maxResults?: number;
+        nextToken?: string;
+    }): Promise<{
+        ScalingPolicies: ScalingPolicy[];
+        NextToken?: string;
+    }>;
+    /**
+     * Delete a scaling policy
+     */
+    deleteScalingPolicy(options: {
+        policyName: string;
+        serviceNamespace: ServiceNamespace;
+        resourceId: string;
+        scalableDimension: ScalableDimension;
+    }): Promise<void>;
+    /**
+     * Put a scheduled action
+     */
+    putScheduledAction(options: {
+        scheduledActionName: string;
+        serviceNamespace: ServiceNamespace;
+        resourceId: string;
+        scalableDimension: ScalableDimension;
+        schedule: string;
+        timezone?: string;
+        startTime?: Date;
+        endTime?: Date;
+        scalableTargetAction?: {
+            minCapacity?: number;
+            maxCapacity?: number;
+        };
+    }): Promise<void>;
+    /**
+     * Describe scheduled actions
+     */
+    describeScheduledActions(options: {
+        serviceNamespace: ServiceNamespace;
+        scheduledActionNames?: string[];
+        resourceId?: string;
+        scalableDimension?: ScalableDimension;
+        maxResults?: number;
+        nextToken?: string;
+    }): Promise<{
+        ScheduledActions: ScheduledAction[];
+        NextToken?: string;
+    }>;
+    /**
+     * Delete a scheduled action
+     */
+    deleteScheduledAction(options: {
+        scheduledActionName: string;
+        serviceNamespace: ServiceNamespace;
+        resourceId: string;
+        scalableDimension: ScalableDimension;
+    }): Promise<void>;
+    /**
+     * Describe scaling activities
+     */
+    describeScalingActivities(options: {
+        serviceNamespace: ServiceNamespace;
+        resourceId?: string;
+        scalableDimension?: ScalableDimension;
+        maxResults?: number;
+        nextToken?: string;
+        includeNotScaledActivities?: boolean;
+    }): Promise<{
+        ScalingActivities: Array<{
+            ActivityId: string;
+            ServiceNamespace: string;
+            ResourceId: string;
+            ScalableDimension: string;
+            Description: string;
+            Cause: string;
+            StartTime: string;
+            EndTime?: string;
+            StatusCode: 'Pending' | 'InProgress' | 'Successful' | 'Overridden' | 'Unfulfilled' | 'Failed';
+            StatusMessage?: string;
+            Details?: string;
+            NotScaledReasons?: Array<{
+                Code: string;
+                MaxCapacity?: number;
+                MinCapacity?: number;
+                CurrentCapacity?: number;
+            }>;
+        }>;
+        NextToken?: string;
+    }>;
+    /**
+     * Helper: Get the resource ID format for an ECS service
+     */
+    getECSServiceResourceId(clusterName: string, serviceName: string): string;
+    /**
+     * Helper: Register an ECS service for auto-scaling
+     */
+    registerECSServiceScaling(options: {
+        clusterName: string;
+        serviceName: string;
+        minCapacity: number;
+        maxCapacity: number;
+    }): Promise<void>;
+    /**
+     * Helper: Create a CPU-based scaling policy for an ECS service
+     */
+    createECSCPUScalingPolicy(options: {
+        clusterName: string;
+        serviceName: string;
+        policyName: string;
+        targetCPUPercent: number;
+        scaleOutCooldown?: number;
+        scaleInCooldown?: number;
+        disableScaleIn?: boolean;
+    }): Promise<{
+        PolicyARN: string;
+        Alarms: Array<{
+            AlarmName: string;
+            AlarmARN: string;
+        }>;
+    }>;
+    /**
+     * Helper: Create a memory-based scaling policy for an ECS service
+     */
+    createECSMemoryScalingPolicy(options: {
+        clusterName: string;
+        serviceName: string;
+        policyName: string;
+        targetMemoryPercent: number;
+        scaleOutCooldown?: number;
+        scaleInCooldown?: number;
+        disableScaleIn?: boolean;
+    }): Promise<{
+        PolicyARN: string;
+        Alarms: Array<{
+            AlarmName: string;
+            AlarmARN: string;
+        }>;
+    }>;
+    /**
+     * Helper: Create an ALB request count scaling policy for an ECS service
+     */
+    createECSRequestCountScalingPolicy(options: {
+        clusterName: string;
+        serviceName: string;
+        policyName: string;
+        targetRequestsPerTarget: number;
+        targetGroupArn: string;
+        loadBalancerArn: string;
+        scaleOutCooldown?: number;
+        scaleInCooldown?: number;
+        disableScaleIn?: boolean;
+    }): Promise<{
+        PolicyARN: string;
+        Alarms: Array<{
+            AlarmName: string;
+            AlarmARN: string;
+        }>;
+    }>;
+    /**
+     * Helper: Get all scaling policies for an ECS service
+     */
+    getECSServiceScalingPolicies(clusterName: string, serviceName: string): Promise<ScalingPolicy[]>;
+    /**
+     * Helper: Remove all auto-scaling from an ECS service
+     */
+    removeECSServiceScaling(clusterName: string, serviceName: string): Promise<void>;
+    /**
+     * Helper: Create a scheduled scaling action for an ECS service
+     * Example schedule: "cron(0 9 * * ? *)" for 9 AM daily
+     */
+    createECSScheduledScaling(options: {
+        clusterName: string;
+        serviceName: string;
+        actionName: string;
+        schedule: string;
+        timezone?: string;
+        minCapacity?: number;
+        maxCapacity?: number;
+    }): Promise<void>;
+    /**
+     * Helper: Get scaling activity history for an ECS service
+     */
+    getECSScalingActivities(clusterName: string, serviceName: string, maxResults?: number): Promise<Array<{
+        ActivityId: string;
+        Description: string;
+        Cause: string;
+        StartTime: string;
+        EndTime?: string;
+        StatusCode: string;
+        StatusMessage?: string;
+    }>>;
+}