@stacksjs/ts-cloud 0.1.11 → 0.1.14

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/ts-cloud",
   "type": "module",
-  "version": "0.1.11",
+  "version": "0.1.14",
   "description": "A lightweight, performant infrastructure-as-code library and CLI for deploying both server-based (EC2) and serverless applications.",
   "author": "Chris Breuer <chris@stacksjs.com>",
   "license": "MIT",
@@ -85,14 +85,14 @@
     "test": "bun test"
   },
   "dependencies": {
-    "ts-cloud-aws-types": "0.1.11",
-    "ts-cloud-core": "0.1.11",
-    "ts-cloud-types": "0.1.11",
-    "fast-xml-parser": "^5.3.5"
+    "ts-cloud-aws-types": "0.1.14",
+    "ts-cloud-core": "0.1.14",
+    "ts-cloud-types": "0.1.14",
+    "fast-xml-parser": "^5.4.2"
   },
   "devDependencies": {
     "bunfig": "^0.15.6",
-    "better-dx": "^0.2.5"
+    "better-dx": "^0.2.6"
   },
   "lint-staged": {
     "*.{js,ts,json,yaml,yml,md}": "bunx --bun pickier lint --fix"

package/dist/aws/acm.d.ts

@@ -1,129 +0,0 @@
-import { AWSClient } from './client';
-import { Route53Client } from './route53';
-import type { DnsProvider, DnsProviderConfig } from '../dns/types';
-export declare 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: AWSClient;
-  private region: string;
-  constructor(region?: string);
-  requestCertificate(params: {
-    DomainName: string
-    SubjectAlternativeNames?: string[]
-    ValidationMethod?: 'EMAIL' | 'DNS'
-  }): Promise<{
-    CertificateArn: string
-  }>;
-  describeCertificate(params: {
-    CertificateArn: string
-  }): Promise<CertificateDetail>;
-  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
-  }>;
-  deleteCertificate(params: {
-    CertificateArn: string
-  }): Promise<void>;
-  listTagsForCertificate(params: {
-    CertificateArn: string
-  }): Promise<{ Tags: Array<{ Key: string, Value?: string }> }>;
-  addTagsToCertificate(params: {
-    CertificateArn: string
-    Tags: Array<{ Key: string, Value?: string }>
-  }): Promise<void>;
-  resendValidationEmail(params: {
-    CertificateArn: string
-    Domain: string
-    ValidationDomain: string
-  }): Promise<void>;
-  findCertificateByDomain(domainName: string): Promise<CertificateDetail | null>;
-  waitForCertificateValidation(certificateArn: string, maxAttempts?: any, delayMs?: any): Promise<CertificateDetail | null>;
-  getDnsValidationRecords(certificateArn: string): Promise<Array<{
-    domainName: string
-    recordName: string
-    recordType: string
-    recordValue: string
-  }>>;
-  requestCertificateWithSans(params: {
-    DomainName: string
-    IncludeWww?: boolean
-    IncludeWildcard?: boolean
-    AdditionalSans?: string[]
-  }): Promise<{ CertificateArn: string }>;
-  isCertificateValidForDomain(certificateArn: string, domainName: string): Promise<boolean>;
-}
-/**
- * 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: ACMClient;
-  private route53: Route53Client;
-  private dnsProvider?: DnsProvider;
-  constructor(region?: string, dnsProviderConfig?: DnsProviderConfig);
-  requestAndValidate(params: {
-    domainName: string
-    hostedZoneId?: string
-    subjectAlternativeNames?: string[]
-    waitForValidation?: boolean
-    maxWaitMinutes?: number
-  }): Promise<{
-    certificateArn: string
-    validationRecords: Array<{
-      domainName: string
-      recordName: string
-      recordValue: string
-    }>
-  }>;
-  private waitForValidationOptions(certificateArn: string, maxAttempts?: any): Promise<void>;
-  createValidationRecords(params: {
-    certificateArn: string
-    hostedZoneId?: string
-    domain?: string
-  }): Promise<Array<{
-    domainName: string
-    recordName: string
-    recordValue: string
-    changeId?: string
-  }>>;
-  deleteValidationRecords(params: {
-    certificateArn: string
-    hostedZoneId?: string
-    domain?: string
-  }): Promise<void>;
-  findOrCreateCertificate(params: {
-    domainName: string
-    hostedZoneId?: string
-    subjectAlternativeNames?: string[]
-    waitForValidation?: boolean
-  }): Promise<{
-    certificateArn: string
-    isNew: boolean
-  }>;
-  hasExternalDnsProvider(): boolean;
-  getDnsProviderName(): string;
-}

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

@@ -1,282 +0,0 @@
-import { AWSClient } from './client';
-export declare interface ScalableTarget {
-  ServiceNamespace: ServiceNamespace
-  ResourceId: string
-  ScalableDimension: ScalableDimension
-  MinCapacity: number
-  MaxCapacity: number
-  RoleARN?: string
-  CreationTime?: string
-  SuspendedState?: {
-    DynamicScalingInSuspended?: boolean
-    DynamicScalingOutSuspended?: boolean
-    ScheduledScalingSuspended?: boolean
-  }
-}
-export declare 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 declare interface StepScalingPolicyConfiguration {
-  AdjustmentType: 'ChangeInCapacity' | 'PercentChangeInCapacity' | 'ExactCapacity'
-  StepAdjustments: Array<{
-    MetricIntervalLowerBound?: number
-    MetricIntervalUpperBound?: number
-    ScalingAdjustment: number
-  }>
-  MinAdjustmentMagnitude?: number
-  Cooldown?: number
-  MetricAggregationType?: 'Average' | 'Minimum' | 'Maximum'
-}
-export declare 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 declare 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
-}
-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'
-/**
- * Application Auto Scaling client for ECS, DynamoDB, and other services
- */
-export declare class ApplicationAutoScalingClient {
-  private client: AWSClient;
-  private region: string;
-  constructor(region?: string);
-  registerScalableTarget(options: {
-    serviceNamespace: ServiceNamespace
-    resourceId: string
-    scalableDimension: ScalableDimension
-    minCapacity: number
-    maxCapacity: number
-    roleARN?: string
-    suspendedState?: {
-      dynamicScalingInSuspended?: boolean
-      dynamicScalingOutSuspended?: boolean
-      scheduledScalingSuspended?: boolean
-    }
-  }): Promise<void>;
-  describeScalableTargets(options: {
-    serviceNamespace: ServiceNamespace
-    resourceIds?: string[]
-    scalableDimension?: ScalableDimension
-    maxResults?: number
-    nextToken?: string
-  }): Promise<{ ScalableTargets: ScalableTarget[], NextToken?: string }>;
-  deregisterScalableTarget(options: {
-    serviceNamespace: ServiceNamespace
-    resourceId: string
-    scalableDimension: ScalableDimension
-  }): Promise<void>;
-  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 }> }>;
-  describeScalingPolicies(options: {
-    serviceNamespace: ServiceNamespace
-    policyNames?: string[]
-    resourceId?: string
-    scalableDimension?: ScalableDimension
-    maxResults?: number
-    nextToken?: string
-  }): Promise<{ ScalingPolicies: ScalingPolicy[], NextToken?: string }>;
-  deleteScalingPolicy(options: {
-    policyName: string
-    serviceNamespace: ServiceNamespace
-    resourceId: string
-    scalableDimension: ScalableDimension
-  }): Promise<void>;
-  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>;
-  describeScheduledActions(options: {
-    serviceNamespace: ServiceNamespace
-    scheduledActionNames?: string[]
-    resourceId?: string
-    scalableDimension?: ScalableDimension
-    maxResults?: number
-    nextToken?: string
-  }): Promise<{ ScheduledActions: ScheduledAction[], NextToken?: string }>;
-  deleteScheduledAction(options: {
-    scheduledActionName: string
-    serviceNamespace: ServiceNamespace
-    resourceId: string
-    scalableDimension: ScalableDimension
-  }): Promise<void>;
-  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
-  }>;
-  getECSServiceResourceId(clusterName: string, serviceName: string): string;
-  registerECSServiceScaling(options: {
-    clusterName: string
-    serviceName: string
-    minCapacity: number
-    maxCapacity: number
-  }): Promise<void>;
-  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 }> }>;
-  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 }> }>;
-  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 }> }>;
-  getECSServiceScalingPolicies(clusterName: string, serviceName: string): Promise<ScalingPolicy[]>;
-  removeECSServiceScaling(clusterName: string, serviceName: string): Promise<void>;
-  createECSScheduledScaling(options: {
-    clusterName: string
-    serviceName: string
-    actionName: string
-    schedule: string
-    timezone?: string
-    minCapacity?: number
-    maxCapacity?: number
-  }): Promise<void>;
-  getECSScalingActivities(clusterName: string, serviceName: string, maxResults?: any): Promise<Array<{
-    ActivityId: string
-    Description: string
-    Cause: string
-    StartTime: string
-    EndTime?: string
-    StatusCode: string
-    StatusMessage?: string
-  }>>;
-}