@stacksjs/ts-cloud 0.5.6 → 0.5.7

package/dist/index.js

@@ -26471,7 +26471,10 @@ function composeServerlessAppTemplate(opts) {
         DatabaseName: "app",
         MasterUsername: Fn2.sub("{{resolve:secretsmanager:${DbSecret}:SecretString:username}}"),
         MasterUserPassword: Fn2.sub("{{resolve:secretsmanager:${DbSecret}:SecretString:password}}"),
-        ServerlessV2ScalingConfiguration: { MinCapacity: 0.5, MaxCapacity: 4 },
+        ServerlessV2ScalingConfiguration: {
+          MinCapacity: app.database?.minCapacity ?? 0.5,
+          MaxCapacity: app.database?.maxCapacity ?? 4
+        },
         DBSubnetGroupName: Fn2.ref("DbSubnetGroup"),
         VpcSecurityGroupIds: [Fn2.getAtt("DataSecurityGroup", "GroupId")]
       }
@@ -55715,405 +55718,1001 @@ var init_email = __esm(() => {
   email = new EmailClient;
 });
 
-// src/deploy/static-site-external-dns.ts
-function generateExternalDnsStaticSiteTemplate(config6) {
-  const {
-    bucketName,
-    domain,
-    aliases,
-    certificateArn,
-    defaultRootObject = "index.html",
-    errorDocument = "404.html",
-    passthroughUrls = false,
-    singlePageApp = false,
-    dynamicApp = false,
-    computeOriginDomain,
-    computeOriginPort = 3008,
-    computeOriginId = "app-compute",
-    retainOnStackDelete = false
-  } = config6;
-  const retainPolicy = retainOnStackDelete ? { DeletionPolicy: "Retain", UpdateReplacePolicy: "Retain" } : {};
-  const useComputeOrigin = dynamicApp && !!computeOriginDomain;
-  const defaultAllowedMethods = useComputeOrigin ? ["GET", "HEAD", "OPTIONS", "PUT", "POST", "PATCH", "DELETE"] : ["GET", "HEAD"];
-  const defaultCachedMethods = useComputeOrigin ? ["GET", "HEAD"] : ["GET", "HEAD"];
-  const resources = {};
-  const outputs = {};
-  resources.S3Bucket = {
-    Type: "AWS::S3::Bucket",
-    ...retainPolicy,
-    Properties: {
-      BucketName: bucketName,
-      PublicAccessBlockConfiguration: {
-        BlockPublicAcls: true,
-        BlockPublicPolicy: false,
-        IgnorePublicAcls: true,
-        RestrictPublicBuckets: false
-      },
-      WebsiteConfiguration: {
-        IndexDocument: defaultRootObject,
-        ErrorDocument: errorDocument
-      }
+// src/aws/rds.ts
+class RDSClient {
+  client;
+  region;
+  constructor(region = "us-east-1") {
+    this.region = region;
+    this.client = new AWSClient;
+  }
+  async describeDBInstances(options) {
+    const params = {
+      Action: "DescribeDBInstances",
+      Version: "2014-10-31"
+    };
+    if (options?.DBInstanceIdentifier) {
+      params.DBInstanceIdentifier = options.DBInstanceIdentifier;
     }
-  };
-  outputs.BucketName = {
-    Description: "S3 Bucket Name",
-    Value: { Ref: "S3Bucket" }
-  };
-  outputs.BucketArn = {
-    Description: "S3 Bucket ARN",
-    Value: { "Fn::GetAtt": ["S3Bucket", "Arn"] }
-  };
-  resources.CloudFrontOAC = {
-    Type: "AWS::CloudFront::OriginAccessControl",
-    ...retainPolicy,
-    Properties: {
-      OriginAccessControlConfig: {
-        Name: `OAC-${bucketName}`,
-        Description: `OAC for ${bucketName}`,
-        OriginAccessControlOriginType: "s3",
-        SigningBehavior: "always",
-        SigningProtocol: "sigv4"
-      }
+    if (options?.MaxRecords) {
+      params.MaxRecords = options.MaxRecords;
     }
-  };
-  let installRootRedirectLogicalId;
-  if (passthroughUrls && useComputeOrigin) {
-    installRootRedirectLogicalId = "InstallRootRedirectFunction";
-    resources[installRootRedirectLogicalId] = {
-      Type: "AWS::CloudFront::Function",
-      Properties: {
-        Name: { "Fn::Sub": "${AWS::StackName}-install-root-redirect" },
-        AutoPublish: true,
-        FunctionConfig: {
-          Comment: "Redirect curl pantry.dev | bash (GET /) to /install.sh on S3",
-          Runtime: "cloudfront-js-2.0"
-        },
-        FunctionCode: `function handler(event) {
-  var request = event.request;
-  if (request.uri === '/' || request.uri === '') {
-    return {
-      statusCode: 302,
-      statusDescription: 'Found',
+    if (options?.Marker) {
+      params.Marker = options.Marker;
+    }
+    if (options?.Filters) {
+      options.Filters.forEach((filter, i) => {
+        params[`Filters.Filter.${i + 1}.Name`] = filter.Name;
+        filter.Values.forEach((value, j) => {
+          params[`Filters.Filter.${i + 1}.Values.Value.${j + 1}`] = value;
+        });
+      });
+    }
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
       headers: {
-        location: { value: 'https://' + request.headers.host.value + '/install.sh' }
-      }
-    };
-  }
-  return request;
-}`
-      }
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: queryString
+    });
+    const response = result.DescribeDBInstancesResult || result;
+    let instances = response.DBInstances?.DBInstance || [];
+    if (!Array.isArray(instances)) {
+      instances = instances ? [instances] : [];
+    }
+    return {
+      DBInstances: instances,
+      Marker: response.Marker
     };
   }
-  if (!passthroughUrls) {
-    resources.UrlRewriteFunction = {
-      Type: "AWS::CloudFront::Function",
-      Properties: {
-        Name: { "Fn::Sub": "${AWS::StackName}-url-rewrite" },
-        AutoPublish: true,
-        FunctionConfig: {
-          Comment: "Append .html extension to URLs without extensions",
-          Runtime: "cloudfront-js-2.0"
-        },
-        FunctionCode: `function handler(event) {
-  const request = event.request;
-  var uri = request.uri;
-
-  // If URI ends with /, serve index.html
-  if (uri.endsWith('/')) {
-    request.uri = uri + 'index.html';
-  }
-  // If URI doesn't have an extension, append .html
-  else if (!uri.includes('.')) {
-    request.uri = uri + '.html';
+  async describeDBInstance(dbInstanceIdentifier) {
+    const result = await this.describeDBInstances({ DBInstanceIdentifier: dbInstanceIdentifier });
+    return result.DBInstances?.[0];
   }
-
-  return request;
-}`
-      }
+  async describeDBClusters(options) {
+    const params = {
+      Action: "DescribeDBClusters",
+      Version: "2014-10-31"
     };
-  }
-  const s3Origin = {
-    Id: `S3-${bucketName}`,
-    DomainName: { "Fn::GetAtt": ["S3Bucket", "RegionalDomainName"] },
-    S3OriginConfig: {
-      OriginAccessIdentity: ""
-    },
-    OriginAccessControlId: { "Fn::GetAtt": ["CloudFrontOAC", "Id"] }
-  };
-  const computeOrigin = useComputeOrigin ? {
-    Id: computeOriginId,
-    DomainName: computeOriginDomain,
-    CustomOriginConfig: {
-      HTTPPort: computeOriginPort,
-      HTTPSPort: 443,
-      OriginProtocolPolicy: "http-only",
-      OriginSSLProtocols: ["TLSv1.2"]
+    if (options?.DBClusterIdentifier) {
+      params.DBClusterIdentifier = options.DBClusterIdentifier;
     }
-  } : null;
-  const defaultTargetOriginId = useComputeOrigin ? computeOriginId : `S3-${bucketName}`;
-  const distributionConfig = {
-    Enabled: true,
-    DefaultRootObject: defaultRootObject,
-    HttpVersion: "http2and3",
-    IPV6Enabled: true,
-    PriceClass: "PriceClass_100",
-    Origins: computeOrigin ? [computeOrigin, s3Origin] : [s3Origin],
-    DefaultCacheBehavior: {
-      TargetOriginId: defaultTargetOriginId,
-      ViewerProtocolPolicy: "redirect-to-https",
-      AllowedMethods: defaultAllowedMethods,
-      CachedMethods: defaultCachedMethods,
-      Compress: true,
-      ...useComputeOrigin ? {
-        CachePolicyId: "4135ea2d-6df8-44a3-9df3-4b5a84be39ad",
-        OriginRequestPolicyId: "b689b0a8-53d0-40ab-baf2-68738e2966ac",
-        ...passthroughUrls && installRootRedirectLogicalId ? {
-          FunctionAssociations: [{
-            EventType: "viewer-request",
-            FunctionARN: { "Fn::GetAtt": [installRootRedirectLogicalId, "FunctionARN"] }
-          }]
-        } : {}
-      } : {
-        CachePolicyId: "658327ea-f89d-4fab-a63d-7e88639e58f6",
-        ...!passthroughUrls && {
-          FunctionAssociations: [
-            {
-              EventType: "viewer-request",
-              FunctionARN: { "Fn::GetAtt": ["UrlRewriteFunction", "FunctionARN"] }
-            }
-          ]
-        }
-      }
-    },
-    ...useComputeOrigin && passthroughUrls ? {
-      CacheBehaviors: [
-        {
-          PathPattern: "/install.sh",
-          TargetOriginId: `S3-${bucketName}`,
-          ViewerProtocolPolicy: "redirect-to-https",
-          AllowedMethods: ["GET", "HEAD", "OPTIONS"],
-          CachedMethods: ["GET", "HEAD", "OPTIONS"],
-          Compress: true,
-          CachePolicyId: "658327ea-f89d-4fab-a63d-7e88639e58f6"
-        }
-      ]
-    } : {},
-    CustomErrorResponses: singlePageApp ? [
-      {
-        ErrorCode: 403,
-        ResponseCode: 200,
-        ResponsePagePath: `/${defaultRootObject}`,
-        ErrorCachingMinTTL: 300
-      },
-      {
-        ErrorCode: 404,
-        ResponseCode: 200,
-        ResponsePagePath: `/${defaultRootObject}`,
-        ErrorCachingMinTTL: 300
-      }
-    ] : [
-      {
-        ErrorCode: 403,
-        ResponseCode: 404,
-        ResponsePagePath: `/${errorDocument}`,
-        ErrorCachingMinTTL: 300
+    if (options?.MaxRecords) {
+      params.MaxRecords = options.MaxRecords;
+    }
+    if (options?.Marker) {
+      params.Marker = options.Marker;
+    }
+    if (options?.Filters) {
+      options.Filters.forEach((filter, i) => {
+        params[`Filters.Filter.${i + 1}.Name`] = filter.Name;
+        filter.Values.forEach((value, j) => {
+          params[`Filters.Filter.${i + 1}.Values.Value.${j + 1}`] = value;
+        });
+      });
+    }
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
       },
-      {
-        ErrorCode: 404,
-        ResponseCode: 404,
-        ResponsePagePath: `/${errorDocument}`,
-        ErrorCachingMinTTL: 300
-      }
-    ]
-  };
-  if (domain && certificateArn) {
-    distributionConfig.Aliases = aliases && aliases.length > 0 ? aliases : [domain];
-    distributionConfig.ViewerCertificate = {
-      AcmCertificateArn: certificateArn,
-      SslSupportMethod: "sni-only",
-      MinimumProtocolVersion: "TLSv1.2_2021"
-    };
-  } else {
-    distributionConfig.ViewerCertificate = {
-      CloudFrontDefaultCertificate: true
+      body: queryString
+    });
+    const response = result.DescribeDBClustersResult || result;
+    let clusters = response.DBClusters?.DBCluster || [];
+    if (!Array.isArray(clusters)) {
+      clusters = clusters ? [clusters] : [];
+    }
+    return {
+      DBClusters: clusters,
+      Marker: response.Marker
     };
   }
-  resources.CloudFrontDistribution = {
-    Type: "AWS::CloudFront::Distribution",
-    ...retainPolicy,
-    DependsOn: [
-      "S3Bucket",
-      "CloudFrontOAC",
-      ...passthroughUrls && useComputeOrigin && installRootRedirectLogicalId ? [installRootRedirectLogicalId] : [],
-      ...!passthroughUrls ? ["UrlRewriteFunction"] : []
-    ],
-    Properties: {
-      DistributionConfig: distributionConfig
+  async describeDBSnapshots(options) {
+    const params = {
+      Action: "DescribeDBSnapshots",
+      Version: "2014-10-31"
+    };
+    if (options?.DBInstanceIdentifier) {
+      params.DBInstanceIdentifier = options.DBInstanceIdentifier;
     }
-  };
-  outputs.DistributionId = {
-    Description: "CloudFront Distribution ID",
-    Value: { Ref: "CloudFrontDistribution" }
-  };
-  outputs.DistributionDomain = {
-    Description: "CloudFront Distribution Domain",
-    Value: { "Fn::GetAtt": ["CloudFrontDistribution", "DomainName"] }
-  };
-  resources.S3BucketPolicy = {
-    Type: "AWS::S3::BucketPolicy",
-    ...retainPolicy,
-    DependsOn: ["S3Bucket", "CloudFrontDistribution"],
-    Properties: {
-      Bucket: { Ref: "S3Bucket" },
-      PolicyDocument: {
-        Version: "2012-10-17",
-        Statement: [
-          {
-            Sid: "AllowCloudFrontServicePrincipal",
-            Effect: "Allow",
-            Principal: {
-              Service: "cloudfront.amazonaws.com"
-            },
-            Action: "s3:GetObject",
-            Resource: { "Fn::Sub": "arn:aws:s3:::${S3Bucket}/*" },
-            Condition: {
-              StringEquals: {
-                "AWS:SourceArn": {
-                  "Fn::Sub": "arn:aws:cloudfront::${AWS::AccountId}:distribution/${CloudFrontDistribution}"
-                }
-              }
-            }
-          }
-        ]
-      }
+    if (options?.DBSnapshotIdentifier) {
+      params.DBSnapshotIdentifier = options.DBSnapshotIdentifier;
     }
-  };
-  outputs.SiteUrl = {
-    Description: "Site URL",
-    Value: domain ? `https://${domain}` : { "Fn::Sub": "https://${CloudFrontDistribution.DomainName}" }
-  };
-  return {
-    AWSTemplateFormatVersion: "2010-09-09",
-    Description: `Static site infrastructure for ${domain || bucketName} (External DNS)`,
-    Resources: resources,
-    Outputs: outputs
-  };
-}
-async function deployStaticSiteWithExternalDns(config6) {
-  const region = config6.region || "us-east-1";
-  const cfRegion = "us-east-1";
-  const domain = config6.domain;
-  const bucket = config6.bucket || domain.replace(/\./g, "-");
-  const stackName = config6.stackName || `${config6.siteName}-static-site`;
-  const cf = new CloudFormationClient(cfRegion);
-  const acm2 = new ACMClient("us-east-1");
-  let dnsProvider = null;
-  if (!config6.skipDnsVerification) {
-    dnsProvider = createDnsProvider(config6.dnsProvider);
-    console.log(`Verifying DNS provider can manage ${domain}...`);
-    const verify = await dnsProvider.listRecords(domain);
-    if (!verify.success) {
-      const reason = verify.message || "unknown error — check API credentials and domain ownership";
-      return {
-        success: false,
-        stackName,
-        bucket,
-        message: `DNS provider '${dnsProvider.name}' cannot manage domain ${domain}: ${reason}`
-      };
+    if (options?.SnapshotType) {
+      params.SnapshotType = options.SnapshotType;
     }
-    console.log(`DNS provider '${dnsProvider.name}' verified for ${domain}`);
-  } else {
-    console.log(`Skipping DNS verification for ${domain}`);
-  }
-  let certificateArn = config6.certificateArn;
-  const domainParts = domain.split(".");
-  const isApexDomain = domainParts.length === 2;
-  const wwwDomain = isApexDomain ? `www.${domain}` : undefined;
-  if (!certificateArn) {
-    console.log(`Checking for existing SSL certificate for ${domain}...`);
-    const existingCert = await acm2.findCertificateByDomain(domain);
-    let existingCertCoversWww = false;
-    if (existingCert && existingCert.Status === "ISSUED") {
-      if (wwwDomain && existingCert.SubjectAlternativeNames) {
-        existingCertCoversWww = existingCert.SubjectAlternativeNames.includes(wwwDomain) || existingCert.SubjectAlternativeNames.some((san) => san === `*.${domain}`);
-      } else {
-        existingCertCoversWww = true;
-      }
-      if (existingCertCoversWww) {
-        certificateArn = existingCert.CertificateArn;
-        console.log(`Found existing certificate with www coverage: ${certificateArn}`);
-      } else {
-        console.log(`Existing certificate doesn't cover ${wwwDomain}, requesting new one...`);
-      }
+    if (options?.MaxRecords) {
+      params.MaxRecords = options.MaxRecords;
     }
-    if (!certificateArn) {
-      if (!dnsProvider) {
-        return {
-          success: false,
-          stackName,
-          bucket,
-          message: `No DNS provider available to validate SSL certificate for ${domain}. Provide a certificateArn or enable DNS verification.`
-        };
-      }
-      console.log(`Requesting new SSL certificate for ${domain}${wwwDomain ? ` (including ${wwwDomain})` : ""}...`);
-      const validator = new UnifiedDnsValidator(dnsProvider, "us-east-1");
-      const certResult = await validator.findOrCreateCertificate({
-        domainName: domain,
-        subjectAlternativeNames: wwwDomain ? [wwwDomain] : undefined,
-        waitForValidation: true,
-        maxWaitMinutes: 10
-      });
-      if (certResult.status !== "issued") {
-        return {
-          success: false,
-          stackName,
-          bucket,
-          message: `SSL certificate validation failed. Status: ${certResult.status}`
-        };
-      }
-      certificateArn = certResult.certificateArn;
-      console.log(`Certificate issued: ${certificateArn}`);
+    if (options?.Marker) {
+      params.Marker = options.Marker;
+    }
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: queryString
+    });
+    const response = result.DescribeDBSnapshotsResult || result;
+    let snapshots = response.DBSnapshots?.DBSnapshot || [];
+    if (!Array.isArray(snapshots)) {
+      snapshots = snapshots ? [snapshots] : [];
     }
+    return {
+      DBSnapshots: snapshots,
+      Marker: response.Marker
+    };
   }
-  let stackExists = false;
-  let existingBucketName;
-  try {
-    const existingStacks = await cf.describeStacks({ stackName });
-    if (existingStacks.Stacks.length > 0) {
-      const stack = existingStacks.Stacks[0];
-      const stackStatus = stack.StackStatus;
-      if (stackStatus === "DELETE_IN_PROGRESS") {
-        console.log("Previous stack is still being deleted, waiting...");
-        await cf.waitForStack(stackName, "stack-delete-complete");
-        stackExists = false;
-      } else if (stackStatus === "DELETE_COMPLETE") {
-        stackExists = false;
-      } else {
-        stackExists = true;
-        const outputs2 = stack.Outputs || [];
-        existingBucketName = outputs2.find((o) => o.OutputKey === "BucketName")?.OutputValue;
-      }
+  async describeDBSubnetGroups(options) {
+    const params = {
+      Action: "DescribeDBSubnetGroups",
+      Version: "2014-10-31"
+    };
+    if (options?.DBSubnetGroupName) {
+      params.DBSubnetGroupName = options.DBSubnetGroupName;
     }
-  } catch (err) {
-    if (err.message?.includes("does not exist") || err.code === "ValidationError") {
-      stackExists = false;
-    } else {
-      throw err;
+    if (options?.MaxRecords) {
+      params.MaxRecords = options.MaxRecords;
     }
-  }
-  let finalBucket = existingBucketName || bucket;
-  if (!stackExists) {
-    const s32 = new S3Client2(region);
-    const cloudfront2 = new CloudFrontClient;
-    let hasExistingDistribution = false;
-    if (domain) {
-      try {
-        console.log(`Checking for existing CloudFront distributions with alias ${domain}...`);
-        const distributions = await cloudfront2.listDistributions();
-        for (const dist of distributions) {
-          let aliases2 = [];
-          if (dist.Aliases?.Items) {
-            if (Array.isArray(dist.Aliases.Items)) {
+    if (options?.Marker) {
+      params.Marker = options.Marker;
+    }
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: queryString
+    });
+    const response = result.DescribeDBSubnetGroupsResult || result;
+    let groups = response.DBSubnetGroups?.DBSubnetGroup || [];
+    if (!Array.isArray(groups)) {
+      groups = groups ? [groups] : [];
+    }
+    return {
+      DBSubnetGroups: groups,
+      Marker: response.Marker
+    };
+  }
+  async createDBInstance(options) {
+    const params = {
+      Action: "CreateDBInstance",
+      Version: "2014-10-31",
+      DBInstanceIdentifier: options.DBInstanceIdentifier,
+      DBInstanceClass: options.DBInstanceClass,
+      Engine: options.Engine
+    };
+    if (options.MasterUsername)
+      params.MasterUsername = options.MasterUsername;
+    if (options.MasterUserPassword)
+      params.MasterUserPassword = options.MasterUserPassword;
+    if (options.DBName)
+      params.DBName = options.DBName;
+    if (options.AllocatedStorage)
+      params.AllocatedStorage = options.AllocatedStorage;
+    if (options.DBSubnetGroupName)
+      params.DBSubnetGroupName = options.DBSubnetGroupName;
+    if (options.AvailabilityZone)
+      params.AvailabilityZone = options.AvailabilityZone;
+    if (options.PreferredMaintenanceWindow)
+      params.PreferredMaintenanceWindow = options.PreferredMaintenanceWindow;
+    if (options.PreferredBackupWindow)
+      params.PreferredBackupWindow = options.PreferredBackupWindow;
+    if (options.BackupRetentionPeriod !== undefined)
+      params.BackupRetentionPeriod = options.BackupRetentionPeriod;
+    if (options.MultiAZ !== undefined)
+      params.MultiAZ = options.MultiAZ;
+    if (options.EngineVersion)
+      params.EngineVersion = options.EngineVersion;
+    if (options.AutoMinorVersionUpgrade !== undefined)
+      params.AutoMinorVersionUpgrade = options.AutoMinorVersionUpgrade;
+    if (options.LicenseModel)
+      params.LicenseModel = options.LicenseModel;
+    if (options.PubliclyAccessible !== undefined)
+      params.PubliclyAccessible = options.PubliclyAccessible;
+    if (options.StorageType)
+      params.StorageType = options.StorageType;
+    if (options.StorageEncrypted !== undefined)
+      params.StorageEncrypted = options.StorageEncrypted;
+    if (options.KmsKeyId)
+      params.KmsKeyId = options.KmsKeyId;
+    if (options.DeletionProtection !== undefined)
+      params.DeletionProtection = options.DeletionProtection;
+    if (options.VpcSecurityGroupIds) {
+      options.VpcSecurityGroupIds.forEach((id, i) => {
+        params[`VpcSecurityGroupIds.VpcSecurityGroupId.${i + 1}`] = id;
+      });
+    }
+    if (options.Tags) {
+      options.Tags.forEach((tag, i) => {
+        params[`Tags.Tag.${i + 1}.Key`] = tag.Key;
+        params[`Tags.Tag.${i + 1}.Value`] = tag.Value;
+      });
+    }
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: queryString
+    });
+    const response = result.CreateDBInstanceResult || result;
+    return {
+      DBInstance: response.DBInstance
+    };
+  }
+  async deleteDBInstance(options) {
+    const params = {
+      Action: "DeleteDBInstance",
+      Version: "2014-10-31",
+      DBInstanceIdentifier: options.DBInstanceIdentifier
+    };
+    if (options.SkipFinalSnapshot !== undefined) {
+      params.SkipFinalSnapshot = options.SkipFinalSnapshot;
+    }
+    if (options.FinalDBSnapshotIdentifier) {
+      params.FinalDBSnapshotIdentifier = options.FinalDBSnapshotIdentifier;
+    }
+    if (options.DeleteAutomatedBackups !== undefined) {
+      params.DeleteAutomatedBackups = options.DeleteAutomatedBackups;
+    }
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: queryString
+    });
+    const response = result.DeleteDBInstanceResult || result;
+    return {
+      DBInstance: response.DBInstance
+    };
+  }
+  async modifyDBInstance(options) {
+    const params = {
+      Action: "ModifyDBInstance",
+      Version: "2014-10-31",
+      DBInstanceIdentifier: options.DBInstanceIdentifier
+    };
+    if (options.DBInstanceClass)
+      params.DBInstanceClass = options.DBInstanceClass;
+    if (options.AllocatedStorage)
+      params.AllocatedStorage = options.AllocatedStorage;
+    if (options.MasterUserPassword)
+      params.MasterUserPassword = options.MasterUserPassword;
+    if (options.BackupRetentionPeriod !== undefined)
+      params.BackupRetentionPeriod = options.BackupRetentionPeriod;
+    if (options.PreferredBackupWindow)
+      params.PreferredBackupWindow = options.PreferredBackupWindow;
+    if (options.PreferredMaintenanceWindow)
+      params.PreferredMaintenanceWindow = options.PreferredMaintenanceWindow;
+    if (options.MultiAZ !== undefined)
+      params.MultiAZ = options.MultiAZ;
+    if (options.EngineVersion)
+      params.EngineVersion = options.EngineVersion;
+    if (options.AutoMinorVersionUpgrade !== undefined)
+      params.AutoMinorVersionUpgrade = options.AutoMinorVersionUpgrade;
+    if (options.PubliclyAccessible !== undefined)
+      params.PubliclyAccessible = options.PubliclyAccessible;
+    if (options.ApplyImmediately !== undefined)
+      params.ApplyImmediately = options.ApplyImmediately;
+    if (options.StorageType)
+      params.StorageType = options.StorageType;
+    if (options.DeletionProtection !== undefined)
+      params.DeletionProtection = options.DeletionProtection;
+    if (options.VpcSecurityGroupIds) {
+      options.VpcSecurityGroupIds.forEach((id, i) => {
+        params[`VpcSecurityGroupIds.VpcSecurityGroupId.${i + 1}`] = id;
+      });
+    }
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: queryString
+    });
+    const response = result.ModifyDBInstanceResult || result;
+    return {
+      DBInstance: response.DBInstance
+    };
+  }
+  async modifyDBCluster(options) {
+    const params = {
+      Action: "ModifyDBCluster",
+      Version: "2014-10-31",
+      DBClusterIdentifier: options.DBClusterIdentifier
+    };
+    if (options.ServerlessV2ScalingConfiguration) {
+      params["ServerlessV2ScalingConfiguration.MinCapacity"] = options.ServerlessV2ScalingConfiguration.MinCapacity;
+      params["ServerlessV2ScalingConfiguration.MaxCapacity"] = options.ServerlessV2ScalingConfiguration.MaxCapacity;
+    }
+    if (options.BackupRetentionPeriod !== undefined)
+      params.BackupRetentionPeriod = options.BackupRetentionPeriod;
+    if (options.ApplyImmediately !== undefined)
+      params.ApplyImmediately = options.ApplyImmediately;
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: queryString
+    });
+    const response = result.ModifyDBClusterResult || result;
+    return { DBCluster: response.DBCluster };
+  }
+  async restoreDBClusterToPointInTime(options) {
+    const params = {
+      Action: "RestoreDBClusterToPointInTime",
+      Version: "2014-10-31",
+      DBClusterIdentifier: options.DBClusterIdentifier,
+      SourceDBClusterIdentifier: options.SourceDBClusterIdentifier
+    };
+    if (options.RestoreToTime)
+      params.RestoreToTime = options.RestoreToTime.toISOString();
+    if (options.UseLatestRestorableTime)
+      params.UseLatestRestorableTime = true;
+    if (options.DBSubnetGroupName)
+      params.DBSubnetGroupName = options.DBSubnetGroupName;
+    if (options.VpcSecurityGroupIds) {
+      options.VpcSecurityGroupIds.forEach((id, i) => {
+        params[`VpcSecurityGroupIds.VpcSecurityGroupId.${i + 1}`] = id;
+      });
+    }
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: queryString
+    });
+    const response = result.RestoreDBClusterToPointInTimeResult || result;
+    return { DBCluster: response.DBCluster };
+  }
+  async startDBInstance(dbInstanceIdentifier) {
+    const params = {
+      Action: "StartDBInstance",
+      Version: "2014-10-31",
+      DBInstanceIdentifier: dbInstanceIdentifier
+    };
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: queryString
+    });
+    const response = result.StartDBInstanceResult || result;
+    return {
+      DBInstance: response.DBInstance
+    };
+  }
+  async stopDBInstance(options) {
+    const params = {
+      Action: "StopDBInstance",
+      Version: "2014-10-31",
+      DBInstanceIdentifier: options.DBInstanceIdentifier
+    };
+    if (options.DBSnapshotIdentifier) {
+      params.DBSnapshotIdentifier = options.DBSnapshotIdentifier;
+    }
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: queryString
+    });
+    const response = result.StopDBInstanceResult || result;
+    return {
+      DBInstance: response.DBInstance
+    };
+  }
+  async rebootDBInstance(options) {
+    const params = {
+      Action: "RebootDBInstance",
+      Version: "2014-10-31",
+      DBInstanceIdentifier: options.DBInstanceIdentifier
+    };
+    if (options.ForceFailover !== undefined) {
+      params.ForceFailover = options.ForceFailover;
+    }
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: queryString
+    });
+    const response = result.RebootDBInstanceResult || result;
+    return {
+      DBInstance: response.DBInstance
+    };
+  }
+  async createDBSnapshot(options) {
+    const params = {
+      Action: "CreateDBSnapshot",
+      Version: "2014-10-31",
+      DBInstanceIdentifier: options.DBInstanceIdentifier,
+      DBSnapshotIdentifier: options.DBSnapshotIdentifier
+    };
+    if (options.Tags) {
+      options.Tags.forEach((tag, i) => {
+        params[`Tags.Tag.${i + 1}.Key`] = tag.Key;
+        params[`Tags.Tag.${i + 1}.Value`] = tag.Value;
+      });
+    }
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: queryString
+    });
+    const response = result.CreateDBSnapshotResult || result;
+    return {
+      DBSnapshot: response.DBSnapshot
+    };
+  }
+  async deleteDBSnapshot(dbSnapshotIdentifier) {
+    const params = {
+      Action: "DeleteDBSnapshot",
+      Version: "2014-10-31",
+      DBSnapshotIdentifier: dbSnapshotIdentifier
+    };
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: queryString
+    });
+    const response = result.DeleteDBSnapshotResult || result;
+    return {
+      DBSnapshot: response.DBSnapshot
+    };
+  }
+  async restoreDBInstanceFromDBSnapshot(options) {
+    const params = {
+      Action: "RestoreDBInstanceFromDBSnapshot",
+      Version: "2014-10-31",
+      DBInstanceIdentifier: options.DBInstanceIdentifier,
+      DBSnapshotIdentifier: options.DBSnapshotIdentifier
+    };
+    if (options.DBInstanceClass)
+      params.DBInstanceClass = options.DBInstanceClass;
+    if (options.Port)
+      params.Port = options.Port;
+    if (options.AvailabilityZone)
+      params.AvailabilityZone = options.AvailabilityZone;
+    if (options.DBSubnetGroupName)
+      params.DBSubnetGroupName = options.DBSubnetGroupName;
+    if (options.MultiAZ !== undefined)
+      params.MultiAZ = options.MultiAZ;
+    if (options.PubliclyAccessible !== undefined)
+      params.PubliclyAccessible = options.PubliclyAccessible;
+    if (options.AutoMinorVersionUpgrade !== undefined)
+      params.AutoMinorVersionUpgrade = options.AutoMinorVersionUpgrade;
+    if (options.StorageType)
+      params.StorageType = options.StorageType;
+    if (options.DeletionProtection !== undefined)
+      params.DeletionProtection = options.DeletionProtection;
+    if (options.VpcSecurityGroupIds) {
+      options.VpcSecurityGroupIds.forEach((id, i) => {
+        params[`VpcSecurityGroupIds.VpcSecurityGroupId.${i + 1}`] = id;
+      });
+    }
+    if (options.Tags) {
+      options.Tags.forEach((tag, i) => {
+        params[`Tags.Tag.${i + 1}.Key`] = tag.Key;
+        params[`Tags.Tag.${i + 1}.Value`] = tag.Value;
+      });
+    }
+    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    const result = await this.client.request({
+      service: "rds",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: queryString
+    });
+    const response = result.RestoreDBInstanceFromDBSnapshotResult || result;
+    return {
+      DBInstance: response.DBInstance
+    };
+  }
+  async waitForDBInstanceAvailable(dbInstanceIdentifier, maxAttempts = 60, delayMs = 30000) {
+    for (let i = 0;i < maxAttempts; i++) {
+      const instance = await this.describeDBInstance(dbInstanceIdentifier);
+      if (instance?.DBInstanceStatus === "available") {
+        return instance;
+      }
+      if (["deleted", "failed", "incompatible-restore", "incompatible-parameters"].includes(instance?.DBInstanceStatus || "")) {
+        throw new Error(`DB instance ${dbInstanceIdentifier} is in terminal state: ${instance?.DBInstanceStatus}`);
+      }
+      await new Promise((resolve14) => setTimeout(resolve14, delayMs));
+    }
+    throw new Error(`Timeout waiting for DB instance ${dbInstanceIdentifier} to become available`);
+  }
+  async waitForDBInstanceDeleted(dbInstanceIdentifier, maxAttempts = 60, delayMs = 30000) {
+    for (let i = 0;i < maxAttempts; i++) {
+      try {
+        const instance = await this.describeDBInstance(dbInstanceIdentifier);
+        if (instance?.DBInstanceStatus === "deleting") {
+          await new Promise((resolve14) => setTimeout(resolve14, delayMs));
+          continue;
+        }
+        throw new Error(`DB instance ${dbInstanceIdentifier} is in state: ${instance?.DBInstanceStatus}`);
+      } catch (error) {
+        if (error.code === "DBInstanceNotFound" || error.code === "DBInstanceNotFoundFault") {
+          return;
+        }
+        throw error;
+      }
+    }
+    throw new Error(`Timeout waiting for DB instance ${dbInstanceIdentifier} to be deleted`);
+  }
+}
+var init_rds = __esm(() => {
+  init_client();
+});
+
+// src/deploy/static-site-external-dns.ts
+function generateExternalDnsStaticSiteTemplate(config6) {
+  const {
+    bucketName,
+    domain,
+    aliases,
+    certificateArn,
+    defaultRootObject = "index.html",
+    errorDocument = "404.html",
+    passthroughUrls = false,
+    singlePageApp = false,
+    dynamicApp = false,
+    computeOriginDomain,
+    computeOriginPort = 3008,
+    computeOriginId = "app-compute",
+    retainOnStackDelete = false
+  } = config6;
+  const retainPolicy = retainOnStackDelete ? { DeletionPolicy: "Retain", UpdateReplacePolicy: "Retain" } : {};
+  const useComputeOrigin = dynamicApp && !!computeOriginDomain;
+  const defaultAllowedMethods = useComputeOrigin ? ["GET", "HEAD", "OPTIONS", "PUT", "POST", "PATCH", "DELETE"] : ["GET", "HEAD"];
+  const defaultCachedMethods = useComputeOrigin ? ["GET", "HEAD"] : ["GET", "HEAD"];
+  const resources = {};
+  const outputs = {};
+  resources.S3Bucket = {
+    Type: "AWS::S3::Bucket",
+    ...retainPolicy,
+    Properties: {
+      BucketName: bucketName,
+      PublicAccessBlockConfiguration: {
+        BlockPublicAcls: true,
+        BlockPublicPolicy: false,
+        IgnorePublicAcls: true,
+        RestrictPublicBuckets: false
+      },
+      WebsiteConfiguration: {
+        IndexDocument: defaultRootObject,
+        ErrorDocument: errorDocument
+      }
+    }
+  };
+  outputs.BucketName = {
+    Description: "S3 Bucket Name",
+    Value: { Ref: "S3Bucket" }
+  };
+  outputs.BucketArn = {
+    Description: "S3 Bucket ARN",
+    Value: { "Fn::GetAtt": ["S3Bucket", "Arn"] }
+  };
+  resources.CloudFrontOAC = {
+    Type: "AWS::CloudFront::OriginAccessControl",
+    ...retainPolicy,
+    Properties: {
+      OriginAccessControlConfig: {
+        Name: `OAC-${bucketName}`,
+        Description: `OAC for ${bucketName}`,
+        OriginAccessControlOriginType: "s3",
+        SigningBehavior: "always",
+        SigningProtocol: "sigv4"
+      }
+    }
+  };
+  let installRootRedirectLogicalId;
+  if (passthroughUrls && useComputeOrigin) {
+    installRootRedirectLogicalId = "InstallRootRedirectFunction";
+    resources[installRootRedirectLogicalId] = {
+      Type: "AWS::CloudFront::Function",
+      Properties: {
+        Name: { "Fn::Sub": "${AWS::StackName}-install-root-redirect" },
+        AutoPublish: true,
+        FunctionConfig: {
+          Comment: "Redirect curl pantry.dev | bash (GET /) to /install.sh on S3",
+          Runtime: "cloudfront-js-2.0"
+        },
+        FunctionCode: `function handler(event) {
+  var request = event.request;
+  if (request.uri === '/' || request.uri === '') {
+    return {
+      statusCode: 302,
+      statusDescription: 'Found',
+      headers: {
+        location: { value: 'https://' + request.headers.host.value + '/install.sh' }
+      }
+    };
+  }
+  return request;
+}`
+      }
+    };
+  }
+  if (!passthroughUrls) {
+    resources.UrlRewriteFunction = {
+      Type: "AWS::CloudFront::Function",
+      Properties: {
+        Name: { "Fn::Sub": "${AWS::StackName}-url-rewrite" },
+        AutoPublish: true,
+        FunctionConfig: {
+          Comment: "Append .html extension to URLs without extensions",
+          Runtime: "cloudfront-js-2.0"
+        },
+        FunctionCode: `function handler(event) {
+  const request = event.request;
+  var uri = request.uri;
+
+  // If URI ends with /, serve index.html
+  if (uri.endsWith('/')) {
+    request.uri = uri + 'index.html';
+  }
+  // If URI doesn't have an extension, append .html
+  else if (!uri.includes('.')) {
+    request.uri = uri + '.html';
+  }
+
+  return request;
+}`
+      }
+    };
+  }
+  const s3Origin = {
+    Id: `S3-${bucketName}`,
+    DomainName: { "Fn::GetAtt": ["S3Bucket", "RegionalDomainName"] },
+    S3OriginConfig: {
+      OriginAccessIdentity: ""
+    },
+    OriginAccessControlId: { "Fn::GetAtt": ["CloudFrontOAC", "Id"] }
+  };
+  const computeOrigin = useComputeOrigin ? {
+    Id: computeOriginId,
+    DomainName: computeOriginDomain,
+    CustomOriginConfig: {
+      HTTPPort: computeOriginPort,
+      HTTPSPort: 443,
+      OriginProtocolPolicy: "http-only",
+      OriginSSLProtocols: ["TLSv1.2"]
+    }
+  } : null;
+  const defaultTargetOriginId = useComputeOrigin ? computeOriginId : `S3-${bucketName}`;
+  const distributionConfig = {
+    Enabled: true,
+    DefaultRootObject: defaultRootObject,
+    HttpVersion: "http2and3",
+    IPV6Enabled: true,
+    PriceClass: "PriceClass_100",
+    Origins: computeOrigin ? [computeOrigin, s3Origin] : [s3Origin],
+    DefaultCacheBehavior: {
+      TargetOriginId: defaultTargetOriginId,
+      ViewerProtocolPolicy: "redirect-to-https",
+      AllowedMethods: defaultAllowedMethods,
+      CachedMethods: defaultCachedMethods,
+      Compress: true,
+      ...useComputeOrigin ? {
+        CachePolicyId: "4135ea2d-6df8-44a3-9df3-4b5a84be39ad",
+        OriginRequestPolicyId: "b689b0a8-53d0-40ab-baf2-68738e2966ac",
+        ...passthroughUrls && installRootRedirectLogicalId ? {
+          FunctionAssociations: [{
+            EventType: "viewer-request",
+            FunctionARN: { "Fn::GetAtt": [installRootRedirectLogicalId, "FunctionARN"] }
+          }]
+        } : {}
+      } : {
+        CachePolicyId: "658327ea-f89d-4fab-a63d-7e88639e58f6",
+        ...!passthroughUrls && {
+          FunctionAssociations: [
+            {
+              EventType: "viewer-request",
+              FunctionARN: { "Fn::GetAtt": ["UrlRewriteFunction", "FunctionARN"] }
+            }
+          ]
+        }
+      }
+    },
+    ...useComputeOrigin && passthroughUrls ? {
+      CacheBehaviors: [
+        {
+          PathPattern: "/install.sh",
+          TargetOriginId: `S3-${bucketName}`,
+          ViewerProtocolPolicy: "redirect-to-https",
+          AllowedMethods: ["GET", "HEAD", "OPTIONS"],
+          CachedMethods: ["GET", "HEAD", "OPTIONS"],
+          Compress: true,
+          CachePolicyId: "658327ea-f89d-4fab-a63d-7e88639e58f6"
+        }
+      ]
+    } : {},
+    CustomErrorResponses: singlePageApp ? [
+      {
+        ErrorCode: 403,
+        ResponseCode: 200,
+        ResponsePagePath: `/${defaultRootObject}`,
+        ErrorCachingMinTTL: 300
+      },
+      {
+        ErrorCode: 404,
+        ResponseCode: 200,
+        ResponsePagePath: `/${defaultRootObject}`,
+        ErrorCachingMinTTL: 300
+      }
+    ] : [
+      {
+        ErrorCode: 403,
+        ResponseCode: 404,
+        ResponsePagePath: `/${errorDocument}`,
+        ErrorCachingMinTTL: 300
+      },
+      {
+        ErrorCode: 404,
+        ResponseCode: 404,
+        ResponsePagePath: `/${errorDocument}`,
+        ErrorCachingMinTTL: 300
+      }
+    ]
+  };
+  if (domain && certificateArn) {
+    distributionConfig.Aliases = aliases && aliases.length > 0 ? aliases : [domain];
+    distributionConfig.ViewerCertificate = {
+      AcmCertificateArn: certificateArn,
+      SslSupportMethod: "sni-only",
+      MinimumProtocolVersion: "TLSv1.2_2021"
+    };
+  } else {
+    distributionConfig.ViewerCertificate = {
+      CloudFrontDefaultCertificate: true
+    };
+  }
+  resources.CloudFrontDistribution = {
+    Type: "AWS::CloudFront::Distribution",
+    ...retainPolicy,
+    DependsOn: [
+      "S3Bucket",
+      "CloudFrontOAC",
+      ...passthroughUrls && useComputeOrigin && installRootRedirectLogicalId ? [installRootRedirectLogicalId] : [],
+      ...!passthroughUrls ? ["UrlRewriteFunction"] : []
+    ],
+    Properties: {
+      DistributionConfig: distributionConfig
+    }
+  };
+  outputs.DistributionId = {
+    Description: "CloudFront Distribution ID",
+    Value: { Ref: "CloudFrontDistribution" }
+  };
+  outputs.DistributionDomain = {
+    Description: "CloudFront Distribution Domain",
+    Value: { "Fn::GetAtt": ["CloudFrontDistribution", "DomainName"] }
+  };
+  resources.S3BucketPolicy = {
+    Type: "AWS::S3::BucketPolicy",
+    ...retainPolicy,
+    DependsOn: ["S3Bucket", "CloudFrontDistribution"],
+    Properties: {
+      Bucket: { Ref: "S3Bucket" },
+      PolicyDocument: {
+        Version: "2012-10-17",
+        Statement: [
+          {
+            Sid: "AllowCloudFrontServicePrincipal",
+            Effect: "Allow",
+            Principal: {
+              Service: "cloudfront.amazonaws.com"
+            },
+            Action: "s3:GetObject",
+            Resource: { "Fn::Sub": "arn:aws:s3:::${S3Bucket}/*" },
+            Condition: {
+              StringEquals: {
+                "AWS:SourceArn": {
+                  "Fn::Sub": "arn:aws:cloudfront::${AWS::AccountId}:distribution/${CloudFrontDistribution}"
+                }
+              }
+            }
+          }
+        ]
+      }
+    }
+  };
+  outputs.SiteUrl = {
+    Description: "Site URL",
+    Value: domain ? `https://${domain}` : { "Fn::Sub": "https://${CloudFrontDistribution.DomainName}" }
+  };
+  return {
+    AWSTemplateFormatVersion: "2010-09-09",
+    Description: `Static site infrastructure for ${domain || bucketName} (External DNS)`,
+    Resources: resources,
+    Outputs: outputs
+  };
+}
+async function deployStaticSiteWithExternalDns(config6) {
+  const region = config6.region || "us-east-1";
+  const cfRegion = "us-east-1";
+  const domain = config6.domain;
+  const bucket = config6.bucket || domain.replace(/\./g, "-");
+  const stackName = config6.stackName || `${config6.siteName}-static-site`;
+  const cf = new CloudFormationClient(cfRegion);
+  const acm2 = new ACMClient("us-east-1");
+  let dnsProvider = null;
+  if (!config6.skipDnsVerification) {
+    dnsProvider = createDnsProvider(config6.dnsProvider);
+    console.log(`Verifying DNS provider can manage ${domain}...`);
+    const verify = await dnsProvider.listRecords(domain);
+    if (!verify.success) {
+      const reason = verify.message || "unknown error — check API credentials and domain ownership";
+      return {
+        success: false,
+        stackName,
+        bucket,
+        message: `DNS provider '${dnsProvider.name}' cannot manage domain ${domain}: ${reason}`
+      };
+    }
+    console.log(`DNS provider '${dnsProvider.name}' verified for ${domain}`);
+  } else {
+    console.log(`Skipping DNS verification for ${domain}`);
+  }
+  let certificateArn = config6.certificateArn;
+  const domainParts = domain.split(".");
+  const isApexDomain = domainParts.length === 2;
+  const wwwDomain = isApexDomain ? `www.${domain}` : undefined;
+  if (!certificateArn) {
+    console.log(`Checking for existing SSL certificate for ${domain}...`);
+    const existingCert = await acm2.findCertificateByDomain(domain);
+    let existingCertCoversWww = false;
+    if (existingCert && existingCert.Status === "ISSUED") {
+      if (wwwDomain && existingCert.SubjectAlternativeNames) {
+        existingCertCoversWww = existingCert.SubjectAlternativeNames.includes(wwwDomain) || existingCert.SubjectAlternativeNames.some((san) => san === `*.${domain}`);
+      } else {
+        existingCertCoversWww = true;
+      }
+      if (existingCertCoversWww) {
+        certificateArn = existingCert.CertificateArn;
+        console.log(`Found existing certificate with www coverage: ${certificateArn}`);
+      } else {
+        console.log(`Existing certificate doesn't cover ${wwwDomain}, requesting new one...`);
+      }
+    }
+    if (!certificateArn) {
+      if (!dnsProvider) {
+        return {
+          success: false,
+          stackName,
+          bucket,
+          message: `No DNS provider available to validate SSL certificate for ${domain}. Provide a certificateArn or enable DNS verification.`
+        };
+      }
+      console.log(`Requesting new SSL certificate for ${domain}${wwwDomain ? ` (including ${wwwDomain})` : ""}...`);
+      const validator = new UnifiedDnsValidator(dnsProvider, "us-east-1");
+      const certResult = await validator.findOrCreateCertificate({
+        domainName: domain,
+        subjectAlternativeNames: wwwDomain ? [wwwDomain] : undefined,
+        waitForValidation: true,
+        maxWaitMinutes: 10
+      });
+      if (certResult.status !== "issued") {
+        return {
+          success: false,
+          stackName,
+          bucket,
+          message: `SSL certificate validation failed. Status: ${certResult.status}`
+        };
+      }
+      certificateArn = certResult.certificateArn;
+      console.log(`Certificate issued: ${certificateArn}`);
+    }
+  }
+  let stackExists = false;
+  let existingBucketName;
+  try {
+    const existingStacks = await cf.describeStacks({ stackName });
+    if (existingStacks.Stacks.length > 0) {
+      const stack = existingStacks.Stacks[0];
+      const stackStatus = stack.StackStatus;
+      if (stackStatus === "DELETE_IN_PROGRESS") {
+        console.log("Previous stack is still being deleted, waiting...");
+        await cf.waitForStack(stackName, "stack-delete-complete");
+        stackExists = false;
+      } else if (stackStatus === "DELETE_COMPLETE") {
+        stackExists = false;
+      } else {
+        stackExists = true;
+        const outputs2 = stack.Outputs || [];
+        existingBucketName = outputs2.find((o) => o.OutputKey === "BucketName")?.OutputValue;
+      }
+    }
+  } catch (err) {
+    if (err.message?.includes("does not exist") || err.code === "ValidationError") {
+      stackExists = false;
+    } else {
+      throw err;
+    }
+  }
+  let finalBucket = existingBucketName || bucket;
+  if (!stackExists) {
+    const s32 = new S3Client2(region);
+    const cloudfront2 = new CloudFrontClient;
+    let hasExistingDistribution = false;
+    if (domain) {
+      try {
+        console.log(`Checking for existing CloudFront distributions with alias ${domain}...`);
+        const distributions = await cloudfront2.listDistributions();
+        for (const dist of distributions) {
+          let aliases2 = [];
+          if (dist.Aliases?.Items) {
+            if (Array.isArray(dist.Aliases.Items)) {
               aliases2 = dist.Aliases.Items;
             } else if (typeof dist.Aliases.Items === "object") {
               const cname = dist.Aliases.Items.CNAME;
@@ -73620,6 +74219,38 @@ class LambdaClient {
     });
     return result;
   }
+  async updateAlias(params) {
+    const { FunctionName, Name, ...rest } = params;
+    return this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "PUT",
+      path: `/2015-03-31/functions/${encodeURIComponent(FunctionName)}/aliases/${encodeURIComponent(Name)}`,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(rest)
+    });
+  }
+  async putProvisionedConcurrencyConfig(params) {
+    const { FunctionName, Qualifier, ProvisionedConcurrentExecutions } = params;
+    return this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "PUT",
+      path: `/2019-09-30/functions/${encodeURIComponent(FunctionName)}/provisioned-concurrency`,
+      queryParams: { Qualifier },
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ProvisionedConcurrentExecutions })
+    });
+  }
+  async deleteProvisionedConcurrencyConfig(functionName, qualifier) {
+    await this.client.request({
+      service: "lambda",
+      region: this.region,
+      method: "DELETE",
+      path: `/2019-09-30/functions/${encodeURIComponent(functionName)}/provisioned-concurrency`,
+      queryParams: { Qualifier: qualifier }
+    });
+  }
   async waitForFunctionActive(functionName, maxWaitSeconds = 60) {
     const startTime = Date.now();
     const maxWaitMs = maxWaitSeconds * 1000;
@@ -73740,1863 +74371,1329 @@ class LambdaClient {
       queryParams.CompatibleArchitecture = params.CompatibleArchitecture;
     if (params?.MaxItems)
       queryParams.MaxItems = String(params.MaxItems);
-    if (params?.Marker)
-      queryParams.Marker = params.Marker;
-    const result = await this.client.request({
-      service: "lambda",
-      region: this.region,
-      method: "GET",
-      path: `/2018-10-31/layers/${encodeURIComponent(layerName)}/versions`,
-      queryParams: Object.keys(queryParams).length > 0 ? queryParams : undefined,
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-    return result;
-  }
-  async getLayerVersion(layerName, versionNumber) {
-    const result = await this.client.request({
-      service: "lambda",
-      region: this.region,
-      method: "GET",
-      path: `/2018-10-31/layers/${encodeURIComponent(layerName)}/versions/${versionNumber}`,
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-    return result;
-  }
-  async addLayerVersionPermission(params) {
-    const { LayerName, VersionNumber, ...rest } = params;
-    const result = await this.client.request({
-      service: "lambda",
-      region: this.region,
-      method: "POST",
-      path: `/2018-10-31/layers/${encodeURIComponent(LayerName)}/versions/${VersionNumber}/policy`,
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(rest)
-    });
-    return result;
-  }
-  async deleteLayerVersion(layerName, versionNumber) {
-    await this.client.request({
-      service: "lambda",
-      region: this.region,
-      method: "DELETE",
-      path: `/2018-10-31/layers/${encodeURIComponent(layerName)}/versions/${versionNumber}`,
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  }
-}
-// src/aws/cloudwatch-logs.ts
-init_client();
-
-class CloudWatchLogsClient {
-  client;
-  region;
-  constructor(region = "us-east-1", profile) {
-    this.region = region;
-    this.client = new AWSClient;
-  }
-  async describeLogStreams(options) {
-    const params = {
-      logGroupName: options.logGroupName
-    };
-    if (options.logStreamNamePrefix)
-      params.logStreamNamePrefix = options.logStreamNamePrefix;
-    if (options.orderBy)
-      params.orderBy = options.orderBy;
-    if (options.descending !== undefined)
-      params.descending = options.descending;
-    if (options.limit)
-      params.limit = options.limit;
-    const result = await this.client.request({
-      service: "logs",
-      region: this.region,
-      method: "POST",
-      path: "/",
-      headers: {
-        "X-Amz-Target": "Logs_20140328.DescribeLogStreams",
-        "Content-Type": "application/x-amz-json-1.1"
-      },
-      body: JSON.stringify(params)
-    });
-    return result;
-  }
-  async getLogEvents(options) {
-    const params = {
-      logGroupName: options.logGroupName,
-      logStreamName: options.logStreamName
-    };
-    if (options.startTime)
-      params.startTime = options.startTime;
-    if (options.endTime)
-      params.endTime = options.endTime;
-    if (options.limit)
-      params.limit = options.limit;
-    if (options.startFromHead !== undefined)
-      params.startFromHead = options.startFromHead;
-    const result = await this.client.request({
-      service: "logs",
-      region: this.region,
-      method: "POST",
-      path: "/",
-      headers: {
-        "X-Amz-Target": "Logs_20140328.GetLogEvents",
-        "Content-Type": "application/x-amz-json-1.1"
-      },
-      body: JSON.stringify(params)
-    });
-    return result;
-  }
-  async describeLogGroups(options) {
-    const params = {};
-    if (options?.logGroupNamePrefix)
-      params.logGroupNamePrefix = options.logGroupNamePrefix;
-    if (options?.limit)
-      params.limit = options.limit;
-    const result = await this.client.request({
-      service: "logs",
-      region: this.region,
-      method: "POST",
-      path: "/",
-      headers: {
-        "X-Amz-Target": "Logs_20140328.DescribeLogGroups",
-        "Content-Type": "application/x-amz-json-1.1"
-      },
-      body: JSON.stringify(params)
-    });
-    return result;
-  }
-  async deleteLogGroup(logGroupName) {
-    await this.client.request({
-      service: "logs",
-      region: this.region,
-      method: "POST",
-      path: "/",
-      headers: {
-        "X-Amz-Target": "Logs_20140328.DeleteLogGroup",
-        "Content-Type": "application/x-amz-json-1.1"
-      },
-      body: JSON.stringify({ logGroupName })
-    });
-  }
-  async filterLogEvents(options) {
-    const params = {
-      logGroupName: options.logGroupName
-    };
-    if (options.logStreamNames)
-      params.logStreamNames = options.logStreamNames;
-    if (options.startTime)
-      params.startTime = options.startTime;
-    if (options.endTime)
-      params.endTime = options.endTime;
-    if (options.filterPattern)
-      params.filterPattern = options.filterPattern;
-    if (options.limit)
-      params.limit = options.limit;
-    const result = await this.client.request({
-      service: "logs",
-      region: this.region,
-      method: "POST",
-      path: "/",
-      headers: {
-        "X-Amz-Target": "Logs_20140328.FilterLogEvents",
-        "Content-Type": "application/x-amz-json-1.1"
-      },
-      body: JSON.stringify(params)
-    });
-    return result;
-  }
-}
-// src/aws/connect.ts
-init_client();
-
-class ConnectClient {
-  client;
-  region;
-  constructor(region = "us-east-1") {
-    this.region = region;
-    this.client = new AWSClient;
-  }
-  async createInstance(params) {
-    const body = {
-      InstanceAlias: params.InstanceAlias,
-      IdentityManagementType: params.IdentityManagementType || "CONNECT_MANAGED",
-      InboundCallsEnabled: params.InboundCallsEnabled ?? true,
-      OutboundCallsEnabled: params.OutboundCallsEnabled ?? true
-    };
-    if (params.DirectoryId)
-      body.DirectoryId = params.DirectoryId;
-    if (params.ClientToken)
-      body.ClientToken = params.ClientToken;
-    if (params.Tags)
-      body.Tags = params.Tags;
-    const result = await this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "PUT",
-      path: "/instance",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-    return result;
-  }
-  async deleteInstance(instanceId) {
-    await this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "DELETE",
-      path: `/instance/${instanceId}`
-    });
-  }
-  async describeInstance(instanceId) {
-    const result = await this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "GET",
-      path: `/instance/${instanceId}`
-    });
-    return result.Instance || result;
-  }
-  async listInstances(params) {
-    const queryParams = {};
-    if (params?.MaxResults)
-      queryParams.maxResults = String(params.MaxResults);
-    if (params?.NextToken)
-      queryParams.nextToken = params.NextToken;
-    const result = await this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "GET",
-      path: "/instance",
-      queryParams
-    });
-    return result;
-  }
-  async searchAvailablePhoneNumbers(params) {
-    const body = {
-      TargetArn: params.TargetArn,
-      PhoneNumberCountryCode: params.PhoneNumberCountryCode,
-      PhoneNumberType: params.PhoneNumberType
-    };
-    if (params.PhoneNumberPrefix)
-      body.PhoneNumberPrefix = params.PhoneNumberPrefix;
-    if (params.MaxResults)
-      body.MaxResults = params.MaxResults;
-    if (params.NextToken)
-      body.NextToken = params.NextToken;
-    const result = await this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "POST",
-      path: "/phone-number/search-available",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-    return result;
-  }
-  async claimPhoneNumber(params) {
-    const body = {
-      TargetArn: params.TargetArn,
-      PhoneNumber: params.PhoneNumber
-    };
-    if (params.PhoneNumberDescription)
-      body.PhoneNumberDescription = params.PhoneNumberDescription;
-    if (params.Tags)
-      body.Tags = params.Tags;
-    if (params.ClientToken)
-      body.ClientToken = params.ClientToken;
-    const result = await this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "POST",
-      path: "/phone-number/claim",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-    return result;
-  }
-  async releasePhoneNumber(phoneNumberId, clientToken) {
-    const queryParams = {};
-    if (clientToken)
-      queryParams.clientToken = clientToken;
-    await this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "DELETE",
-      path: `/phone-number/${phoneNumberId}`,
-      queryParams
-    });
-  }
-  async listPhoneNumbers(params) {
-    const body = {};
-    if (params.TargetArn)
-      body.TargetArn = params.TargetArn;
-    if (params.InstanceId)
-      body.InstanceId = params.InstanceId;
-    if (params.PhoneNumberTypes)
-      body.PhoneNumberTypes = params.PhoneNumberTypes;
-    if (params.PhoneNumberCountryCodes)
-      body.PhoneNumberCountryCodes = params.PhoneNumberCountryCodes;
-    if (params.MaxResults)
-      body.MaxResults = params.MaxResults;
-    if (params.NextToken)
-      body.NextToken = params.NextToken;
-    const result = await this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "POST",
-      path: "/phone-number/list",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-    return result;
-  }
-  async createContactFlow(params) {
-    const body = {
-      Name: params.Name,
-      Type: params.Type,
-      Content: params.Content
-    };
-    if (params.Description)
-      body.Description = params.Description;
-    if (params.Tags)
-      body.Tags = params.Tags;
-    const result = await this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "PUT",
-      path: `/contact-flows/${params.InstanceId}`,
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-    return result;
-  }
-  async updateContactFlowContent(params) {
-    await this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "POST",
-      path: `/contact-flows/${params.InstanceId}/${params.ContactFlowId}/content`,
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ Content: params.Content })
-    });
-  }
-  async listContactFlows(params) {
-    const queryParams = {};
-    if (params.ContactFlowTypes)
-      queryParams.contactFlowTypes = params.ContactFlowTypes.join(",");
-    if (params.MaxResults)
-      queryParams.maxResults = String(params.MaxResults);
-    if (params.NextToken)
-      queryParams.nextToken = params.NextToken;
+    if (params?.Marker)
+      queryParams.Marker = params.Marker;
     const result = await this.client.request({
-      service: "connect",
+      service: "lambda",
       region: this.region,
       method: "GET",
-      path: `/contact-flows-summary/${params.InstanceId}`,
-      queryParams
+      path: `/2018-10-31/layers/${encodeURIComponent(layerName)}/versions`,
+      queryParams: Object.keys(queryParams).length > 0 ? queryParams : undefined,
+      headers: {
+        "Content-Type": "application/json"
+      }
     });
     return result;
   }
-  async createQueue(params) {
-    const body = {
-      Name: params.Name,
-      HoursOfOperationId: params.HoursOfOperationId
-    };
-    if (params.Description)
-      body.Description = params.Description;
-    if (params.MaxContacts)
-      body.MaxContacts = params.MaxContacts;
-    if (params.OutboundCallerConfig)
-      body.OutboundCallerConfig = params.OutboundCallerConfig;
-    if (params.Tags)
-      body.Tags = params.Tags;
+  async getLayerVersion(layerName, versionNumber) {
     const result = await this.client.request({
-      service: "connect",
+      service: "lambda",
       region: this.region,
-      method: "PUT",
-      path: `/queues/${params.InstanceId}`,
+      method: "GET",
+      path: `/2018-10-31/layers/${encodeURIComponent(layerName)}/versions/${versionNumber}`,
       headers: {
         "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
+      }
     });
     return result;
   }
-  async createHoursOfOperation(params) {
-    const body = {
-      Name: params.Name,
-      TimeZone: params.TimeZone,
-      Config: params.Config
-    };
-    if (params.Description)
-      body.Description = params.Description;
-    if (params.Tags)
-      body.Tags = params.Tags;
+  async addLayerVersionPermission(params) {
+    const { LayerName, VersionNumber, ...rest } = params;
     const result = await this.client.request({
-      service: "connect",
+      service: "lambda",
       region: this.region,
-      method: "PUT",
-      path: `/hours-of-operations/${params.InstanceId}`,
+      method: "POST",
+      path: `/2018-10-31/layers/${encodeURIComponent(LayerName)}/versions/${VersionNumber}/policy`,
       headers: {
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify(rest)
     });
     return result;
   }
-  async associatePhoneNumberContactFlow(params) {
+  async deleteLayerVersion(layerName, versionNumber) {
     await this.client.request({
-      service: "connect",
+      service: "lambda",
       region: this.region,
-      method: "PUT",
-      path: `/phone-number/${params.PhoneNumberId}/contact-flow`,
+      method: "DELETE",
+      path: `/2018-10-31/layers/${encodeURIComponent(layerName)}/versions/${versionNumber}`,
       headers: {
         "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        InstanceId: params.InstanceId,
-        ContactFlowId: params.ContactFlowId
-      })
+      }
     });
   }
-  async createRoutingProfile(params) {
-    const body = {
-      Name: params.Name,
-      DefaultOutboundQueueId: params.DefaultOutboundQueueId,
-      MediaConcurrencies: params.MediaConcurrencies
+}
+// src/aws/cloudwatch-logs.ts
+init_client();
+
+class CloudWatchLogsClient {
+  client;
+  region;
+  constructor(region = "us-east-1", profile) {
+    this.region = region;
+    this.client = new AWSClient;
+  }
+  async describeLogStreams(options) {
+    const params = {
+      logGroupName: options.logGroupName
     };
-    if (params.Description)
-      body.Description = params.Description;
-    if (params.QueueConfigs)
-      body.QueueConfigs = params.QueueConfigs;
-    if (params.Tags)
-      body.Tags = params.Tags;
+    if (options.logStreamNamePrefix)
+      params.logStreamNamePrefix = options.logStreamNamePrefix;
+    if (options.orderBy)
+      params.orderBy = options.orderBy;
+    if (options.descending !== undefined)
+      params.descending = options.descending;
+    if (options.limit)
+      params.limit = options.limit;
     const result = await this.client.request({
-      service: "connect",
+      service: "logs",
       region: this.region,
-      method: "PUT",
-      path: `/routing-profiles/${params.InstanceId}`,
+      method: "POST",
+      path: "/",
       headers: {
-        "Content-Type": "application/json"
+        "X-Amz-Target": "Logs_20140328.DescribeLogStreams",
+        "Content-Type": "application/x-amz-json-1.1"
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify(params)
     });
     return result;
   }
-  async instanceExists(instanceAlias) {
-    try {
-      const result = await this.listInstances({ MaxResults: 100 });
-      return result.InstanceSummaryList?.some((instance) => instance.InstanceAlias === instanceAlias) || false;
-    } catch {
-      return false;
-    }
-  }
-  async startOutboundVoiceContact(params) {
-    const body = {
-      ContactFlowId: params.ContactFlowId,
-      DestinationPhoneNumber: params.DestinationPhoneNumber
+  async getLogEvents(options) {
+    const params = {
+      logGroupName: options.logGroupName,
+      logStreamName: options.logStreamName
     };
-    if (params.SourcePhoneNumber)
-      body.SourcePhoneNumber = params.SourcePhoneNumber;
-    if (params.QueueId)
-      body.QueueId = params.QueueId;
-    if (params.Attributes)
-      body.Attributes = params.Attributes;
-    if (params.AnswerMachineDetectionConfig)
-      body.AnswerMachineDetectionConfig = params.AnswerMachineDetectionConfig;
-    if (params.CampaignId)
-      body.CampaignId = params.CampaignId;
-    if (params.TrafficType)
-      body.TrafficType = params.TrafficType;
-    if (params.ClientToken)
-      body.ClientToken = params.ClientToken;
+    if (options.startTime)
+      params.startTime = options.startTime;
+    if (options.endTime)
+      params.endTime = options.endTime;
+    if (options.limit)
+      params.limit = options.limit;
+    if (options.startFromHead !== undefined)
+      params.startFromHead = options.startFromHead;
     const result = await this.client.request({
-      service: "connect",
+      service: "logs",
       region: this.region,
-      method: "PUT",
-      path: `/contact/outbound-voice/${params.InstanceId}`,
+      method: "POST",
+      path: "/",
       headers: {
-        "Content-Type": "application/json"
+        "X-Amz-Target": "Logs_20140328.GetLogEvents",
+        "Content-Type": "application/x-amz-json-1.1"
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify(params)
     });
     return result;
   }
-  async makeCall(params) {
-    return this.startOutboundVoiceContact({
-      InstanceId: params.instanceId,
-      ContactFlowId: params.contactFlowId,
-      DestinationPhoneNumber: params.to,
-      SourcePhoneNumber: params.from,
-      Attributes: params.attributes
-    });
-  }
-  async stopContact(params) {
-    await this.client.request({
-      service: "connect",
+  async describeLogGroups(options) {
+    const params = {};
+    if (options?.logGroupNamePrefix)
+      params.logGroupNamePrefix = options.logGroupNamePrefix;
+    if (options?.limit)
+      params.limit = options.limit;
+    const result = await this.client.request({
+      service: "logs",
       region: this.region,
       method: "POST",
-      path: `/contact/stop/${params.InstanceId}/${params.ContactId}`
+      path: "/",
+      headers: {
+        "X-Amz-Target": "Logs_20140328.DescribeLogGroups",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify(params)
     });
+    return result;
   }
-  async describeContact(params) {
-    return this.client.request({
-      service: "connect",
+  async deleteLogGroup(logGroupName) {
+    await this.client.request({
+      service: "logs",
       region: this.region,
-      method: "GET",
-      path: `/contacts/${params.InstanceId}/${params.ContactId}`
+      method: "POST",
+      path: "/",
+      headers: {
+        "X-Amz-Target": "Logs_20140328.DeleteLogGroup",
+        "Content-Type": "application/x-amz-json-1.1"
+      },
+      body: JSON.stringify({ logGroupName })
     });
   }
-  async updateContactAttributes(params) {
-    await this.client.request({
-      service: "connect",
+  async filterLogEvents(options) {
+    const params = {
+      logGroupName: options.logGroupName
+    };
+    if (options.logStreamNames)
+      params.logStreamNames = options.logStreamNames;
+    if (options.startTime)
+      params.startTime = options.startTime;
+    if (options.endTime)
+      params.endTime = options.endTime;
+    if (options.filterPattern)
+      params.filterPattern = options.filterPattern;
+    if (options.limit)
+      params.limit = options.limit;
+    const result = await this.client.request({
+      service: "logs",
       region: this.region,
       method: "POST",
-      path: `/contact/attributes/${params.InstanceId}`,
+      path: "/",
       headers: {
-        "Content-Type": "application/json"
+        "X-Amz-Target": "Logs_20140328.FilterLogEvents",
+        "Content-Type": "application/x-amz-json-1.1"
       },
-      body: JSON.stringify({
-        InitialContactId: params.InitialContactId,
-        Attributes: params.Attributes
-      })
+      body: JSON.stringify(params)
     });
+    return result;
   }
-  async createUser(params) {
+}
+// src/aws/connect.ts
+init_client();
+
+class ConnectClient {
+  client;
+  region;
+  constructor(region = "us-east-1") {
+    this.region = region;
+    this.client = new AWSClient;
+  }
+  async createInstance(params) {
     const body = {
-      Username: params.Username,
-      PhoneConfig: params.PhoneConfig,
-      SecurityProfileIds: params.SecurityProfileIds,
-      RoutingProfileId: params.RoutingProfileId
+      InstanceAlias: params.InstanceAlias,
+      IdentityManagementType: params.IdentityManagementType || "CONNECT_MANAGED",
+      InboundCallsEnabled: params.InboundCallsEnabled ?? true,
+      OutboundCallsEnabled: params.OutboundCallsEnabled ?? true
     };
-    if (params.Password)
-      body.Password = params.Password;
-    if (params.IdentityInfo)
-      body.IdentityInfo = params.IdentityInfo;
-    if (params.DirectoryUserId)
-      body.DirectoryUserId = params.DirectoryUserId;
-    if (params.HierarchyGroupId)
-      body.HierarchyGroupId = params.HierarchyGroupId;
+    if (params.DirectoryId)
+      body.DirectoryId = params.DirectoryId;
+    if (params.ClientToken)
+      body.ClientToken = params.ClientToken;
     if (params.Tags)
       body.Tags = params.Tags;
-    return this.client.request({
+    const result = await this.client.request({
       service: "connect",
       region: this.region,
       method: "PUT",
-      path: `/users/${params.InstanceId}`,
+      path: "/instance",
       headers: {
         "Content-Type": "application/json"
       },
       body: JSON.stringify(body)
     });
+    return result;
   }
-  async deleteUser(params) {
+  async deleteInstance(instanceId) {
     await this.client.request({
       service: "connect",
       region: this.region,
       method: "DELETE",
-      path: `/users/${params.InstanceId}/${params.UserId}`
+      path: `/instance/${instanceId}`
     });
   }
-  async listUsers(params) {
-    const queryParams = {};
-    if (params.NextToken)
-      queryParams.nextToken = params.NextToken;
-    if (params.MaxResults)
-      queryParams.maxResults = String(params.MaxResults);
-    return this.client.request({
+  async describeInstance(instanceId) {
+    const result = await this.client.request({
       service: "connect",
       region: this.region,
       method: "GET",
-      path: `/users-summary/${params.InstanceId}`,
-      queryParams
-    });
-  }
-  async createPrompt(params) {
-    const body = {
-      Name: params.Name,
-      S3Uri: params.S3Uri
-    };
-    if (params.Description)
-      body.Description = params.Description;
-    if (params.Tags)
-      body.Tags = params.Tags;
-    return this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "PUT",
-      path: `/prompts/${params.InstanceId}`,
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
+      path: `/instance/${instanceId}`
     });
+    return result.Instance || result;
   }
-  async listPrompts(params) {
+  async listInstances(params) {
     const queryParams = {};
-    if (params.NextToken)
-      queryParams.nextToken = params.NextToken;
-    if (params.MaxResults)
+    if (params?.MaxResults)
       queryParams.maxResults = String(params.MaxResults);
-    return this.client.request({
+    if (params?.NextToken)
+      queryParams.nextToken = params.NextToken;
+    const result = await this.client.request({
       service: "connect",
       region: this.region,
       method: "GET",
-      path: `/prompts-summary/${params.InstanceId}`,
+      path: "/instance",
       queryParams
     });
+    return result;
   }
-  async createQuickConnect(params) {
+  async searchAvailablePhoneNumbers(params) {
     const body = {
-      Name: params.Name,
-      QuickConnectConfig: params.QuickConnectConfig
+      TargetArn: params.TargetArn,
+      PhoneNumberCountryCode: params.PhoneNumberCountryCode,
+      PhoneNumberType: params.PhoneNumberType
     };
-    if (params.Description)
-      body.Description = params.Description;
-    if (params.Tags)
-      body.Tags = params.Tags;
-    return this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "PUT",
-      path: `/quick-connects/${params.InstanceId}`,
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-  }
-  async startChatContact(params) {
-    return this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "PUT",
-      path: `/contact/chat/${params.InstanceId}`,
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(params)
-    });
-  }
-  async startTaskContact(params) {
-    return this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "PUT",
-      path: `/contact/task/${params.InstanceId}`,
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(params)
-    });
-  }
-  createOutboundIvrFlow(params) {
-    const voiceId = params.voiceId || "Joanna";
-    return JSON.stringify({
-      Version: "2019-10-30",
-      StartAction: "play-prompt",
-      Actions: {
-        "play-prompt": {
-          Type: "MessageParticipant",
-          Parameters: {
-            Text: params.message,
-            TextToSpeechVoice: voiceId,
-            TextToSpeechEngine: "neural"
-          },
-          Transitions: {
-            NextAction: "disconnect",
-            Errors: [
-              { NextAction: "disconnect", ErrorType: "NoMatchingError" }
-            ]
-          }
-        },
-        disconnect: {
-          Type: "DisconnectParticipant",
-          Parameters: {},
-          Transitions: {}
-        }
-      }
-    });
-  }
-  createInputCollectionFlow(params) {
-    const voiceId = params.voiceId || "Joanna";
-    const timeout = params.inputTimeout || 5;
-    const maxDigits = params.maxDigits || 1;
-    return JSON.stringify({
-      Version: "2019-10-30",
-      StartAction: "get-input",
-      Actions: {
-        "get-input": {
-          Type: "GetParticipantInput",
-          Parameters: {
-            Text: params.promptMessage,
-            TextToSpeechVoice: voiceId,
-            TextToSpeechEngine: "neural",
-            InputTimeLimitSeconds: String(timeout),
-            MaxDigits: maxDigits,
-            EncryptEntry: false
-          },
-          Transitions: {
-            NextAction: params.successNextAction || "disconnect",
-            Conditions: [],
-            Errors: [
-              { NextAction: "disconnect", ErrorType: "NoMatchingCondition" },
-              { NextAction: "disconnect", ErrorType: "NoMatchingError" }
-            ]
-          }
-        },
-        disconnect: {
-          Type: "DisconnectParticipant",
-          Parameters: {},
-          Transitions: {}
-        }
-      }
-    });
-  }
-  async getCurrentMetricData(params) {
-    return this.client.request({
-      service: "connect",
-      region: this.region,
-      method: "POST",
-      path: `/metrics/current/${params.InstanceId}`,
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(params)
-    });
-  }
-}
-// src/aws/elbv2.ts
-init_client();
-
-class ELBv2Client {
-  client;
-  region;
-  constructor(region = "us-east-1") {
-    this.region = region;
-    this.client = new AWSClient;
-  }
-  async describeLoadBalancers(options) {
-    const params = {};
-    if (options?.LoadBalancerArns) {
-      options.LoadBalancerArns.forEach((arn, index) => {
-        params[`LoadBalancerArns.member.${index + 1}`] = arn;
-      });
-    }
-    if (options?.Names) {
-      options.Names.forEach((name, index) => {
-        params[`Names.member.${index + 1}`] = name;
-      });
-    }
-    if (options?.Marker) {
-      params.Marker = options.Marker;
-    }
-    if (options?.PageSize) {
-      params.PageSize = options.PageSize;
-    }
-    const result = await this.client.request({
-      service: "elasticloadbalancing",
-      region: this.region,
-      method: "POST",
-      path: "/",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: this.buildFormBody("DescribeLoadBalancers", params)
-    });
-    return this.normalizeResult(result, "DescribeLoadBalancersResult");
-  }
-  async describeTargetGroups(options) {
-    const params = {};
-    if (options?.LoadBalancerArn) {
-      params.LoadBalancerArn = options.LoadBalancerArn;
-    }
-    if (options?.TargetGroupArns) {
-      options.TargetGroupArns.forEach((arn, index) => {
-        params[`TargetGroupArns.member.${index + 1}`] = arn;
-      });
-    }
-    if (options?.Names) {
-      options.Names.forEach((name, index) => {
-        params[`Names.member.${index + 1}`] = name;
-      });
-    }
-    if (options?.Marker) {
-      params.Marker = options.Marker;
-    }
-    if (options?.PageSize) {
-      params.PageSize = options.PageSize;
-    }
+    if (params.PhoneNumberPrefix)
+      body.PhoneNumberPrefix = params.PhoneNumberPrefix;
+    if (params.MaxResults)
+      body.MaxResults = params.MaxResults;
+    if (params.NextToken)
+      body.NextToken = params.NextToken;
     const result = await this.client.request({
-      service: "elasticloadbalancing",
+      service: "connect",
       region: this.region,
       method: "POST",
-      path: "/",
+      path: "/phone-number/search-available",
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("DescribeTargetGroups", params)
+      body: JSON.stringify(body)
     });
-    return this.normalizeResult(result, "DescribeTargetGroupsResult");
+    return result;
   }
-  async describeTargetHealth(options) {
-    const params = {
-      TargetGroupArn: options.TargetGroupArn
+  async claimPhoneNumber(params) {
+    const body = {
+      TargetArn: params.TargetArn,
+      PhoneNumber: params.PhoneNumber
     };
-    if (options.Targets) {
-      options.Targets.forEach((target, index) => {
-        params[`Targets.member.${index + 1}.Id`] = target.Id;
-        if (target.Port) {
-          params[`Targets.member.${index + 1}.Port`] = target.Port;
-        }
-        if (target.AvailabilityZone) {
-          params[`Targets.member.${index + 1}.AvailabilityZone`] = target.AvailabilityZone;
-        }
-      });
-    }
+    if (params.PhoneNumberDescription)
+      body.PhoneNumberDescription = params.PhoneNumberDescription;
+    if (params.Tags)
+      body.Tags = params.Tags;
+    if (params.ClientToken)
+      body.ClientToken = params.ClientToken;
     const result = await this.client.request({
-      service: "elasticloadbalancing",
+      service: "connect",
       region: this.region,
       method: "POST",
-      path: "/",
+      path: "/phone-number/claim",
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("DescribeTargetHealth", params)
+      body: JSON.stringify(body)
     });
-    return this.normalizeResult(result, "DescribeTargetHealthResult");
+    return result;
   }
-  async describeListeners(options) {
-    const params = {};
-    if (options?.LoadBalancerArn) {
-      params.LoadBalancerArn = options.LoadBalancerArn;
-    }
-    if (options?.ListenerArns) {
-      options.ListenerArns.forEach((arn, index) => {
-        params[`ListenerArns.member.${index + 1}`] = arn;
-      });
-    }
-    if (options?.Marker) {
-      params.Marker = options.Marker;
-    }
-    if (options?.PageSize) {
-      params.PageSize = options.PageSize;
-    }
+  async releasePhoneNumber(phoneNumberId, clientToken) {
+    const queryParams = {};
+    if (clientToken)
+      queryParams.clientToken = clientToken;
+    await this.client.request({
+      service: "connect",
+      region: this.region,
+      method: "DELETE",
+      path: `/phone-number/${phoneNumberId}`,
+      queryParams
+    });
+  }
+  async listPhoneNumbers(params) {
+    const body = {};
+    if (params.TargetArn)
+      body.TargetArn = params.TargetArn;
+    if (params.InstanceId)
+      body.InstanceId = params.InstanceId;
+    if (params.PhoneNumberTypes)
+      body.PhoneNumberTypes = params.PhoneNumberTypes;
+    if (params.PhoneNumberCountryCodes)
+      body.PhoneNumberCountryCodes = params.PhoneNumberCountryCodes;
+    if (params.MaxResults)
+      body.MaxResults = params.MaxResults;
+    if (params.NextToken)
+      body.NextToken = params.NextToken;
     const result = await this.client.request({
-      service: "elasticloadbalancing",
+      service: "connect",
       region: this.region,
       method: "POST",
-      path: "/",
+      path: "/phone-number/list",
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("DescribeListeners", params)
+      body: JSON.stringify(body)
     });
-    return this.normalizeResult(result, "DescribeListenersResult");
+    return result;
   }
-  async describeRules(options) {
-    const params = {};
-    if (options?.ListenerArn) {
-      params.ListenerArn = options.ListenerArn;
-    }
-    if (options?.RuleArns) {
-      options.RuleArns.forEach((arn, index) => {
-        params[`RuleArns.member.${index + 1}`] = arn;
-      });
-    }
-    if (options?.Marker) {
-      params.Marker = options.Marker;
-    }
-    if (options?.PageSize) {
-      params.PageSize = options.PageSize;
-    }
+  async createContactFlow(params) {
+    const body = {
+      Name: params.Name,
+      Type: params.Type,
+      Content: params.Content
+    };
+    if (params.Description)
+      body.Description = params.Description;
+    if (params.Tags)
+      body.Tags = params.Tags;
     const result = await this.client.request({
-      service: "elasticloadbalancing",
+      service: "connect",
       region: this.region,
-      method: "POST",
-      path: "/",
+      method: "PUT",
+      path: `/contact-flows/${params.InstanceId}`,
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("DescribeRules", params)
+      body: JSON.stringify(body)
     });
-    return this.normalizeResult(result, "DescribeRulesResult");
+    return result;
   }
-  async describeLoadBalancerAttributes(loadBalancerArn) {
-    const params = {
-      LoadBalancerArn: loadBalancerArn
-    };
-    const result = await this.client.request({
-      service: "elasticloadbalancing",
+  async updateContactFlowContent(params) {
+    await this.client.request({
+      service: "connect",
       region: this.region,
       method: "POST",
-      path: "/",
+      path: `/contact-flows/${params.InstanceId}/${params.ContactFlowId}/content`,
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("DescribeLoadBalancerAttributes", params)
+      body: JSON.stringify({ Content: params.Content })
     });
-    return this.normalizeResult(result, "DescribeLoadBalancerAttributesResult");
   }
-  async describeTargetGroupAttributes(targetGroupArn) {
-    const params = {
-      TargetGroupArn: targetGroupArn
+  async listContactFlows(params) {
+    const queryParams = {};
+    if (params.ContactFlowTypes)
+      queryParams.contactFlowTypes = params.ContactFlowTypes.join(",");
+    if (params.MaxResults)
+      queryParams.maxResults = String(params.MaxResults);
+    if (params.NextToken)
+      queryParams.nextToken = params.NextToken;
+    const result = await this.client.request({
+      service: "connect",
+      region: this.region,
+      method: "GET",
+      path: `/contact-flows-summary/${params.InstanceId}`,
+      queryParams
+    });
+    return result;
+  }
+  async createQueue(params) {
+    const body = {
+      Name: params.Name,
+      HoursOfOperationId: params.HoursOfOperationId
     };
+    if (params.Description)
+      body.Description = params.Description;
+    if (params.MaxContacts)
+      body.MaxContacts = params.MaxContacts;
+    if (params.OutboundCallerConfig)
+      body.OutboundCallerConfig = params.OutboundCallerConfig;
+    if (params.Tags)
+      body.Tags = params.Tags;
     const result = await this.client.request({
-      service: "elasticloadbalancing",
+      service: "connect",
       region: this.region,
-      method: "POST",
-      path: "/",
+      method: "PUT",
+      path: `/queues/${params.InstanceId}`,
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("DescribeTargetGroupAttributes", params)
+      body: JSON.stringify(body)
     });
-    return this.normalizeResult(result, "DescribeTargetGroupAttributesResult");
+    return result;
   }
-  async createLoadBalancer(options) {
-    const params = {
-      Name: options.Name
+  async createHoursOfOperation(params) {
+    const body = {
+      Name: params.Name,
+      TimeZone: params.TimeZone,
+      Config: params.Config
     };
-    if (options.Subnets) {
-      options.Subnets.forEach((subnet, index) => {
-        params[`Subnets.member.${index + 1}`] = subnet;
-      });
-    }
-    if (options.SubnetMappings) {
-      options.SubnetMappings.forEach((mapping, index) => {
-        params[`SubnetMappings.member.${index + 1}.SubnetId`] = mapping.SubnetId;
-        if (mapping.AllocationId) {
-          params[`SubnetMappings.member.${index + 1}.AllocationId`] = mapping.AllocationId;
-        }
-        if (mapping.PrivateIPv4Address) {
-          params[`SubnetMappings.member.${index + 1}.PrivateIPv4Address`] = mapping.PrivateIPv4Address;
-        }
-        if (mapping.IPv6Address) {
-          params[`SubnetMappings.member.${index + 1}.IPv6Address`] = mapping.IPv6Address;
-        }
-      });
-    }
-    if (options.SecurityGroups) {
-      options.SecurityGroups.forEach((sg, index) => {
-        params[`SecurityGroups.member.${index + 1}`] = sg;
-      });
-    }
-    if (options.Scheme) {
-      params.Scheme = options.Scheme;
-    }
-    if (options.Type) {
-      params.Type = options.Type;
-    }
-    if (options.IpAddressType) {
-      params.IpAddressType = options.IpAddressType;
-    }
-    if (options.Tags) {
-      options.Tags.forEach((tag, index) => {
-        params[`Tags.member.${index + 1}.Key`] = tag.Key;
-        params[`Tags.member.${index + 1}.Value`] = tag.Value;
-      });
-    }
+    if (params.Description)
+      body.Description = params.Description;
+    if (params.Tags)
+      body.Tags = params.Tags;
     const result = await this.client.request({
-      service: "elasticloadbalancing",
+      service: "connect",
       region: this.region,
-      method: "POST",
-      path: "/",
+      method: "PUT",
+      path: `/hours-of-operations/${params.InstanceId}`,
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("CreateLoadBalancer", params)
+      body: JSON.stringify(body)
     });
-    return this.normalizeResult(result, "CreateLoadBalancerResult");
+    return result;
   }
-  async deleteLoadBalancer(loadBalancerArn) {
-    const params = {
-      LoadBalancerArn: loadBalancerArn
-    };
+  async associatePhoneNumberContactFlow(params) {
     await this.client.request({
-      service: "elasticloadbalancing",
+      service: "connect",
       region: this.region,
-      method: "POST",
-      path: "/",
+      method: "PUT",
+      path: `/phone-number/${params.PhoneNumberId}/contact-flow`,
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("DeleteLoadBalancer", params)
+      body: JSON.stringify({
+        InstanceId: params.InstanceId,
+        ContactFlowId: params.ContactFlowId
+      })
     });
   }
-  async createTargetGroup(options) {
-    const params = {
-      Name: options.Name
+  async createRoutingProfile(params) {
+    const body = {
+      Name: params.Name,
+      DefaultOutboundQueueId: params.DefaultOutboundQueueId,
+      MediaConcurrencies: params.MediaConcurrencies
     };
-    if (options.Protocol)
-      params.Protocol = options.Protocol;
-    if (options.ProtocolVersion)
-      params.ProtocolVersion = options.ProtocolVersion;
-    if (options.Port)
-      params.Port = options.Port;
-    if (options.VpcId)
-      params.VpcId = options.VpcId;
-    if (options.HealthCheckProtocol)
-      params.HealthCheckProtocol = options.HealthCheckProtocol;
-    if (options.HealthCheckPort)
-      params.HealthCheckPort = options.HealthCheckPort;
-    if (options.HealthCheckEnabled !== undefined)
-      params.HealthCheckEnabled = options.HealthCheckEnabled;
-    if (options.HealthCheckPath)
-      params.HealthCheckPath = options.HealthCheckPath;
-    if (options.HealthCheckIntervalSeconds)
-      params.HealthCheckIntervalSeconds = options.HealthCheckIntervalSeconds;
-    if (options.HealthCheckTimeoutSeconds)
-      params.HealthCheckTimeoutSeconds = options.HealthCheckTimeoutSeconds;
-    if (options.HealthyThresholdCount)
-      params.HealthyThresholdCount = options.HealthyThresholdCount;
-    if (options.UnhealthyThresholdCount)
-      params.UnhealthyThresholdCount = options.UnhealthyThresholdCount;
-    if (options.TargetType)
-      params.TargetType = options.TargetType;
-    if (options.IpAddressType)
-      params.IpAddressType = options.IpAddressType;
-    if (options.Matcher) {
-      if (options.Matcher.HttpCode)
-        params["Matcher.HttpCode"] = options.Matcher.HttpCode;
-      if (options.Matcher.GrpcCode)
-        params["Matcher.GrpcCode"] = options.Matcher.GrpcCode;
-    }
-    if (options.Tags) {
-      options.Tags.forEach((tag, index) => {
-        params[`Tags.member.${index + 1}.Key`] = tag.Key;
-        params[`Tags.member.${index + 1}.Value`] = tag.Value;
-      });
-    }
+    if (params.Description)
+      body.Description = params.Description;
+    if (params.QueueConfigs)
+      body.QueueConfigs = params.QueueConfigs;
+    if (params.Tags)
+      body.Tags = params.Tags;
     const result = await this.client.request({
-      service: "elasticloadbalancing",
+      service: "connect",
       region: this.region,
-      method: "POST",
-      path: "/",
+      method: "PUT",
+      path: `/routing-profiles/${params.InstanceId}`,
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("CreateTargetGroup", params)
+      body: JSON.stringify(body)
     });
-    return this.normalizeResult(result, "CreateTargetGroupResult");
+    return result;
   }
-  async deleteTargetGroup(targetGroupArn) {
-    const params = {
-      TargetGroupArn: targetGroupArn
+  async instanceExists(instanceAlias) {
+    try {
+      const result = await this.listInstances({ MaxResults: 100 });
+      return result.InstanceSummaryList?.some((instance) => instance.InstanceAlias === instanceAlias) || false;
+    } catch {
+      return false;
+    }
+  }
+  async startOutboundVoiceContact(params) {
+    const body = {
+      ContactFlowId: params.ContactFlowId,
+      DestinationPhoneNumber: params.DestinationPhoneNumber
     };
-    await this.client.request({
-      service: "elasticloadbalancing",
+    if (params.SourcePhoneNumber)
+      body.SourcePhoneNumber = params.SourcePhoneNumber;
+    if (params.QueueId)
+      body.QueueId = params.QueueId;
+    if (params.Attributes)
+      body.Attributes = params.Attributes;
+    if (params.AnswerMachineDetectionConfig)
+      body.AnswerMachineDetectionConfig = params.AnswerMachineDetectionConfig;
+    if (params.CampaignId)
+      body.CampaignId = params.CampaignId;
+    if (params.TrafficType)
+      body.TrafficType = params.TrafficType;
+    if (params.ClientToken)
+      body.ClientToken = params.ClientToken;
+    const result = await this.client.request({
+      service: "connect",
       region: this.region,
-      method: "POST",
-      path: "/",
+      method: "PUT",
+      path: `/contact/outbound-voice/${params.InstanceId}`,
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("DeleteTargetGroup", params)
+      body: JSON.stringify(body)
     });
+    return result;
   }
-  async registerTargets(options) {
-    const params = {
-      TargetGroupArn: options.TargetGroupArn
-    };
-    options.Targets.forEach((target, index) => {
-      params[`Targets.member.${index + 1}.Id`] = target.Id;
-      if (target.Port) {
-        params[`Targets.member.${index + 1}.Port`] = target.Port;
-      }
-      if (target.AvailabilityZone) {
-        params[`Targets.member.${index + 1}.AvailabilityZone`] = target.AvailabilityZone;
-      }
+  async makeCall(params) {
+    return this.startOutboundVoiceContact({
+      InstanceId: params.instanceId,
+      ContactFlowId: params.contactFlowId,
+      DestinationPhoneNumber: params.to,
+      SourcePhoneNumber: params.from,
+      Attributes: params.attributes
     });
+  }
+  async stopContact(params) {
     await this.client.request({
-      service: "elasticloadbalancing",
+      service: "connect",
       region: this.region,
       method: "POST",
-      path: "/",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: this.buildFormBody("RegisterTargets", params)
+      path: `/contact/stop/${params.InstanceId}/${params.ContactId}`
     });
   }
-  async deregisterTargets(options) {
-    const params = {
-      TargetGroupArn: options.TargetGroupArn
-    };
-    options.Targets.forEach((target, index) => {
-      params[`Targets.member.${index + 1}.Id`] = target.Id;
-      if (target.Port) {
-        params[`Targets.member.${index + 1}.Port`] = target.Port;
-      }
-      if (target.AvailabilityZone) {
-        params[`Targets.member.${index + 1}.AvailabilityZone`] = target.AvailabilityZone;
-      }
+  async describeContact(params) {
+    return this.client.request({
+      service: "connect",
+      region: this.region,
+      method: "GET",
+      path: `/contacts/${params.InstanceId}/${params.ContactId}`
     });
+  }
+  async updateContactAttributes(params) {
     await this.client.request({
-      service: "elasticloadbalancing",
+      service: "connect",
       region: this.region,
       method: "POST",
-      path: "/",
+      path: `/contact/attributes/${params.InstanceId}`,
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("DeregisterTargets", params)
+      body: JSON.stringify({
+        InitialContactId: params.InitialContactId,
+        Attributes: params.Attributes
+      })
     });
   }
-  async createListener(options) {
-    const params = {
-      LoadBalancerArn: options.LoadBalancerArn,
-      Port: options.Port
+  async createUser(params) {
+    const body = {
+      Username: params.Username,
+      PhoneConfig: params.PhoneConfig,
+      SecurityProfileIds: params.SecurityProfileIds,
+      RoutingProfileId: params.RoutingProfileId
     };
-    if (options.Protocol)
-      params.Protocol = options.Protocol;
-    if (options.SslPolicy)
-      params.SslPolicy = options.SslPolicy;
-    if (options.Certificates) {
-      options.Certificates.forEach((cert, index) => {
-        params[`Certificates.member.${index + 1}.CertificateArn`] = cert.CertificateArn;
-      });
-    }
-    options.DefaultActions.forEach((action, index) => {
-      params[`DefaultActions.member.${index + 1}.Type`] = action.Type;
-      if (action.TargetGroupArn) {
-        params[`DefaultActions.member.${index + 1}.TargetGroupArn`] = action.TargetGroupArn;
-      }
-      if (action.Order !== undefined) {
-        params[`DefaultActions.member.${index + 1}.Order`] = action.Order;
-      }
-      if (action.RedirectConfig) {
-        const rc = action.RedirectConfig;
-        if (rc.Protocol)
-          params[`DefaultActions.member.${index + 1}.RedirectConfig.Protocol`] = rc.Protocol;
-        if (rc.Port)
-          params[`DefaultActions.member.${index + 1}.RedirectConfig.Port`] = rc.Port;
-        if (rc.Host)
-          params[`DefaultActions.member.${index + 1}.RedirectConfig.Host`] = rc.Host;
-        if (rc.Path)
-          params[`DefaultActions.member.${index + 1}.RedirectConfig.Path`] = rc.Path;
-        if (rc.Query)
-          params[`DefaultActions.member.${index + 1}.RedirectConfig.Query`] = rc.Query;
-        params[`DefaultActions.member.${index + 1}.RedirectConfig.StatusCode`] = rc.StatusCode;
-      }
-      if (action.FixedResponseConfig) {
-        const fr = action.FixedResponseConfig;
-        if (fr.MessageBody)
-          params[`DefaultActions.member.${index + 1}.FixedResponseConfig.MessageBody`] = fr.MessageBody;
-        params[`DefaultActions.member.${index + 1}.FixedResponseConfig.StatusCode`] = fr.StatusCode;
-        if (fr.ContentType)
-          params[`DefaultActions.member.${index + 1}.FixedResponseConfig.ContentType`] = fr.ContentType;
-      }
-    });
-    if (options.AlpnPolicy) {
-      options.AlpnPolicy.forEach((policy, index) => {
-        params[`AlpnPolicy.member.${index + 1}`] = policy;
-      });
-    }
-    if (options.Tags) {
-      options.Tags.forEach((tag, index) => {
-        params[`Tags.member.${index + 1}.Key`] = tag.Key;
-        params[`Tags.member.${index + 1}.Value`] = tag.Value;
-      });
-    }
-    const result = await this.client.request({
-      service: "elasticloadbalancing",
+    if (params.Password)
+      body.Password = params.Password;
+    if (params.IdentityInfo)
+      body.IdentityInfo = params.IdentityInfo;
+    if (params.DirectoryUserId)
+      body.DirectoryUserId = params.DirectoryUserId;
+    if (params.HierarchyGroupId)
+      body.HierarchyGroupId = params.HierarchyGroupId;
+    if (params.Tags)
+      body.Tags = params.Tags;
+    return this.client.request({
+      service: "connect",
       region: this.region,
-      method: "POST",
-      path: "/",
+      method: "PUT",
+      path: `/users/${params.InstanceId}`,
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("CreateListener", params)
+      body: JSON.stringify(body)
     });
-    return this.normalizeResult(result, "CreateListenerResult");
   }
-  async deleteListener(listenerArn) {
-    const params = {
-      ListenerArn: listenerArn
-    };
+  async deleteUser(params) {
     await this.client.request({
-      service: "elasticloadbalancing",
+      service: "connect",
       region: this.region,
-      method: "POST",
-      path: "/",
+      method: "DELETE",
+      path: `/users/${params.InstanceId}/${params.UserId}`
+    });
+  }
+  async listUsers(params) {
+    const queryParams = {};
+    if (params.NextToken)
+      queryParams.nextToken = params.NextToken;
+    if (params.MaxResults)
+      queryParams.maxResults = String(params.MaxResults);
+    return this.client.request({
+      service: "connect",
+      region: this.region,
+      method: "GET",
+      path: `/users-summary/${params.InstanceId}`,
+      queryParams
+    });
+  }
+  async createPrompt(params) {
+    const body = {
+      Name: params.Name,
+      S3Uri: params.S3Uri
+    };
+    if (params.Description)
+      body.Description = params.Description;
+    if (params.Tags)
+      body.Tags = params.Tags;
+    return this.client.request({
+      service: "connect",
+      region: this.region,
+      method: "PUT",
+      path: `/prompts/${params.InstanceId}`,
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("DeleteListener", params)
+      body: JSON.stringify(body)
     });
   }
-  async modifyListener(options) {
-    const params = {
-      ListenerArn: options.ListenerArn
+  async listPrompts(params) {
+    const queryParams = {};
+    if (params.NextToken)
+      queryParams.nextToken = params.NextToken;
+    if (params.MaxResults)
+      queryParams.maxResults = String(params.MaxResults);
+    return this.client.request({
+      service: "connect",
+      region: this.region,
+      method: "GET",
+      path: `/prompts-summary/${params.InstanceId}`,
+      queryParams
+    });
+  }
+  async createQuickConnect(params) {
+    const body = {
+      Name: params.Name,
+      QuickConnectConfig: params.QuickConnectConfig
     };
-    if (options.Port)
-      params.Port = options.Port;
-    if (options.Protocol)
-      params.Protocol = options.Protocol;
-    if (options.SslPolicy)
-      params.SslPolicy = options.SslPolicy;
-    if (options.Certificates) {
-      options.Certificates.forEach((cert, index) => {
-        params[`Certificates.member.${index + 1}.CertificateArn`] = cert.CertificateArn;
-      });
-    }
-    if (options.DefaultActions) {
-      options.DefaultActions.forEach((action, index) => {
-        if (action.Type)
-          params[`DefaultActions.member.${index + 1}.Type`] = action.Type;
-        if (action.TargetGroupArn)
-          params[`DefaultActions.member.${index + 1}.TargetGroupArn`] = action.TargetGroupArn;
-        if (action.Order !== undefined)
-          params[`DefaultActions.member.${index + 1}.Order`] = action.Order;
-      });
-    }
-    if (options.AlpnPolicy) {
-      options.AlpnPolicy.forEach((policy, index) => {
-        params[`AlpnPolicy.member.${index + 1}`] = policy;
-      });
-    }
-    const result = await this.client.request({
-      service: "elasticloadbalancing",
+    if (params.Description)
+      body.Description = params.Description;
+    if (params.Tags)
+      body.Tags = params.Tags;
+    return this.client.request({
+      service: "connect",
       region: this.region,
-      method: "POST",
-      path: "/",
+      method: "PUT",
+      path: `/quick-connects/${params.InstanceId}`,
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/json"
       },
-      body: this.buildFormBody("ModifyListener", params)
+      body: JSON.stringify(body)
     });
-    return this.normalizeResult(result, "ModifyListenerResult");
   }
-  buildFormBody(action, params) {
-    const formParams = {
-      Action: action,
-      Version: "2015-12-01"
-    };
-    for (const [key, value] of Object.entries(params)) {
-      if (value !== undefined && value !== null) {
-        formParams[key] = String(value);
-      }
-    }
-    return Object.entries(formParams).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+  async startChatContact(params) {
+    return this.client.request({
+      service: "connect",
+      region: this.region,
+      method: "PUT",
+      path: `/contact/chat/${params.InstanceId}`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(params)
+    });
   }
-  normalizeResult(parsed, resultKey) {
-    if (parsed && parsed[resultKey]) {
-      return this.normalizeArrays(parsed[resultKey]);
-    }
-    const responseKey = resultKey.replace("Result", "Response");
-    if (parsed && parsed[responseKey] && parsed[responseKey][resultKey]) {
-      return this.normalizeArrays(parsed[responseKey][resultKey]);
-    }
-    return this.normalizeArrays(parsed);
+  async startTaskContact(params) {
+    return this.client.request({
+      service: "connect",
+      region: this.region,
+      method: "PUT",
+      path: `/contact/task/${params.InstanceId}`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(params)
+    });
   }
-  normalizeArrays(obj) {
-    if (!obj || typeof obj !== "object") {
-      return obj;
-    }
-    if (Array.isArray(obj)) {
-      return obj.map((item) => this.normalizeArrays(item));
-    }
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      const arrayFields = [
-        "LoadBalancers",
-        "TargetGroups",
-        "Listeners",
-        "Rules",
-        "TargetHealthDescriptions",
-        "Attributes",
-        "SecurityGroups",
-        "AvailabilityZones",
-        "Certificates",
-        "DefaultActions",
-        "Conditions",
-        "Actions",
-        "member"
-      ];
-      if (key === "member") {
-        if (Array.isArray(value)) {
-          return value.map((item) => this.normalizeArrays(item));
+  createOutboundIvrFlow(params) {
+    const voiceId = params.voiceId || "Joanna";
+    return JSON.stringify({
+      Version: "2019-10-30",
+      StartAction: "play-prompt",
+      Actions: {
+        "play-prompt": {
+          Type: "MessageParticipant",
+          Parameters: {
+            Text: params.message,
+            TextToSpeechVoice: voiceId,
+            TextToSpeechEngine: "neural"
+          },
+          Transitions: {
+            NextAction: "disconnect",
+            Errors: [
+              { NextAction: "disconnect", ErrorType: "NoMatchingError" }
+            ]
+          }
+        },
+        disconnect: {
+          Type: "DisconnectParticipant",
+          Parameters: {},
+          Transitions: {}
         }
-        return [this.normalizeArrays(value)];
       }
-      if (arrayFields.includes(key)) {
-        if (value && typeof value === "object" && "member" in value) {
-          const memberValue = value.member;
-          result[key] = Array.isArray(memberValue) ? memberValue.map((item) => this.normalizeArrays(item)) : [this.normalizeArrays(memberValue)];
-        } else if (Array.isArray(value)) {
-          result[key] = value.map((item) => this.normalizeArrays(item));
-        } else if (value) {
-          result[key] = [this.normalizeArrays(value)];
-        } else {
-          result[key] = [];
+    });
+  }
+  createInputCollectionFlow(params) {
+    const voiceId = params.voiceId || "Joanna";
+    const timeout = params.inputTimeout || 5;
+    const maxDigits = params.maxDigits || 1;
+    return JSON.stringify({
+      Version: "2019-10-30",
+      StartAction: "get-input",
+      Actions: {
+        "get-input": {
+          Type: "GetParticipantInput",
+          Parameters: {
+            Text: params.promptMessage,
+            TextToSpeechVoice: voiceId,
+            TextToSpeechEngine: "neural",
+            InputTimeLimitSeconds: String(timeout),
+            MaxDigits: maxDigits,
+            EncryptEntry: false
+          },
+          Transitions: {
+            NextAction: params.successNextAction || "disconnect",
+            Conditions: [],
+            Errors: [
+              { NextAction: "disconnect", ErrorType: "NoMatchingCondition" },
+              { NextAction: "disconnect", ErrorType: "NoMatchingError" }
+            ]
+          }
+        },
+        disconnect: {
+          Type: "DisconnectParticipant",
+          Parameters: {},
+          Transitions: {}
         }
-      } else if (typeof value === "object") {
-        result[key] = this.normalizeArrays(value);
-      } else {
-        result[key] = value;
       }
-    }
-    return result;
+    });
+  }
+  async getCurrentMetricData(params) {
+    return this.client.request({
+      service: "connect",
+      region: this.region,
+      method: "POST",
+      path: `/metrics/current/${params.InstanceId}`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(params)
+    });
   }
 }
-// src/aws/rds.ts
+// src/aws/elbv2.ts
 init_client();
 
-class RDSClient {
+class ELBv2Client {
   client;
   region;
   constructor(region = "us-east-1") {
     this.region = region;
     this.client = new AWSClient;
   }
-  async describeDBInstances(options) {
-    const params = {
-      Action: "DescribeDBInstances",
-      Version: "2014-10-31"
-    };
-    if (options?.DBInstanceIdentifier) {
-      params.DBInstanceIdentifier = options.DBInstanceIdentifier;
+  async describeLoadBalancers(options) {
+    const params = {};
+    if (options?.LoadBalancerArns) {
+      options.LoadBalancerArns.forEach((arn, index) => {
+        params[`LoadBalancerArns.member.${index + 1}`] = arn;
+      });
     }
-    if (options?.MaxRecords) {
-      params.MaxRecords = options.MaxRecords;
+    if (options?.Names) {
+      options.Names.forEach((name, index) => {
+        params[`Names.member.${index + 1}`] = name;
+      });
     }
     if (options?.Marker) {
       params.Marker = options.Marker;
     }
-    if (options?.Filters) {
-      options.Filters.forEach((filter, i) => {
-        params[`Filters.Filter.${i + 1}.Name`] = filter.Name;
-        filter.Values.forEach((value, j) => {
-          params[`Filters.Filter.${i + 1}.Values.Value.${j + 1}`] = value;
-        });
-      });
+    if (options?.PageSize) {
+      params.PageSize = options.PageSize;
     }
-    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
     const result = await this.client.request({
-      service: "rds",
+      service: "elasticloadbalancing",
       region: this.region,
       method: "POST",
       path: "/",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: queryString
+      body: this.buildFormBody("DescribeLoadBalancers", params)
     });
-    const response = result.DescribeDBInstancesResult || result;
-    let instances = response.DBInstances?.DBInstance || [];
-    if (!Array.isArray(instances)) {
-      instances = instances ? [instances] : [];
-    }
-    return {
-      DBInstances: instances,
-      Marker: response.Marker
-    };
-  }
-  async describeDBInstance(dbInstanceIdentifier) {
-    const result = await this.describeDBInstances({ DBInstanceIdentifier: dbInstanceIdentifier });
-    return result.DBInstances?.[0];
+    return this.normalizeResult(result, "DescribeLoadBalancersResult");
   }
-  async describeDBClusters(options) {
-    const params = {
-      Action: "DescribeDBClusters",
-      Version: "2014-10-31"
-    };
-    if (options?.DBClusterIdentifier) {
-      params.DBClusterIdentifier = options.DBClusterIdentifier;
+  async describeTargetGroups(options) {
+    const params = {};
+    if (options?.LoadBalancerArn) {
+      params.LoadBalancerArn = options.LoadBalancerArn;
     }
-    if (options?.MaxRecords) {
-      params.MaxRecords = options.MaxRecords;
+    if (options?.TargetGroupArns) {
+      options.TargetGroupArns.forEach((arn, index) => {
+        params[`TargetGroupArns.member.${index + 1}`] = arn;
+      });
+    }
+    if (options?.Names) {
+      options.Names.forEach((name, index) => {
+        params[`Names.member.${index + 1}`] = name;
+      });
     }
     if (options?.Marker) {
       params.Marker = options.Marker;
     }
-    if (options?.Filters) {
-      options.Filters.forEach((filter, i) => {
-        params[`Filters.Filter.${i + 1}.Name`] = filter.Name;
-        filter.Values.forEach((value, j) => {
-          params[`Filters.Filter.${i + 1}.Values.Value.${j + 1}`] = value;
-        });
-      });
+    if (options?.PageSize) {
+      params.PageSize = options.PageSize;
     }
-    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
     const result = await this.client.request({
-      service: "rds",
+      service: "elasticloadbalancing",
       region: this.region,
       method: "POST",
       path: "/",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: queryString
+      body: this.buildFormBody("DescribeTargetGroups", params)
     });
-    const response = result.DescribeDBClustersResult || result;
-    let clusters = response.DBClusters?.DBCluster || [];
-    if (!Array.isArray(clusters)) {
-      clusters = clusters ? [clusters] : [];
-    }
-    return {
-      DBClusters: clusters,
-      Marker: response.Marker
-    };
+    return this.normalizeResult(result, "DescribeTargetGroupsResult");
   }
-  async describeDBSnapshots(options) {
+  async describeTargetHealth(options) {
     const params = {
-      Action: "DescribeDBSnapshots",
-      Version: "2014-10-31"
+      TargetGroupArn: options.TargetGroupArn
     };
-    if (options?.DBInstanceIdentifier) {
-      params.DBInstanceIdentifier = options.DBInstanceIdentifier;
-    }
-    if (options?.DBSnapshotIdentifier) {
-      params.DBSnapshotIdentifier = options.DBSnapshotIdentifier;
-    }
-    if (options?.SnapshotType) {
-      params.SnapshotType = options.SnapshotType;
-    }
-    if (options?.MaxRecords) {
-      params.MaxRecords = options.MaxRecords;
-    }
-    if (options?.Marker) {
-      params.Marker = options.Marker;
+    if (options.Targets) {
+      options.Targets.forEach((target, index) => {
+        params[`Targets.member.${index + 1}.Id`] = target.Id;
+        if (target.Port) {
+          params[`Targets.member.${index + 1}.Port`] = target.Port;
+        }
+        if (target.AvailabilityZone) {
+          params[`Targets.member.${index + 1}.AvailabilityZone`] = target.AvailabilityZone;
+        }
+      });
     }
-    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
     const result = await this.client.request({
-      service: "rds",
+      service: "elasticloadbalancing",
       region: this.region,
       method: "POST",
       path: "/",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: queryString
+      body: this.buildFormBody("DescribeTargetHealth", params)
     });
-    const response = result.DescribeDBSnapshotsResult || result;
-    let snapshots = response.DBSnapshots?.DBSnapshot || [];
-    if (!Array.isArray(snapshots)) {
-      snapshots = snapshots ? [snapshots] : [];
-    }
-    return {
-      DBSnapshots: snapshots,
-      Marker: response.Marker
-    };
+    return this.normalizeResult(result, "DescribeTargetHealthResult");
   }
-  async describeDBSubnetGroups(options) {
-    const params = {
-      Action: "DescribeDBSubnetGroups",
-      Version: "2014-10-31"
-    };
-    if (options?.DBSubnetGroupName) {
-      params.DBSubnetGroupName = options.DBSubnetGroupName;
+  async describeListeners(options) {
+    const params = {};
+    if (options?.LoadBalancerArn) {
+      params.LoadBalancerArn = options.LoadBalancerArn;
     }
-    if (options?.MaxRecords) {
-      params.MaxRecords = options.MaxRecords;
+    if (options?.ListenerArns) {
+      options.ListenerArns.forEach((arn, index) => {
+        params[`ListenerArns.member.${index + 1}`] = arn;
+      });
     }
     if (options?.Marker) {
       params.Marker = options.Marker;
     }
-    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    if (options?.PageSize) {
+      params.PageSize = options.PageSize;
+    }
     const result = await this.client.request({
-      service: "rds",
+      service: "elasticloadbalancing",
       region: this.region,
       method: "POST",
       path: "/",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: queryString
+      body: this.buildFormBody("DescribeListeners", params)
     });
-    const response = result.DescribeDBSubnetGroupsResult || result;
-    let groups = response.DBSubnetGroups?.DBSubnetGroup || [];
-    if (!Array.isArray(groups)) {
-      groups = groups ? [groups] : [];
-    }
-    return {
-      DBSubnetGroups: groups,
-      Marker: response.Marker
-    };
+    return this.normalizeResult(result, "DescribeListenersResult");
   }
-  async createDBInstance(options) {
-    const params = {
-      Action: "CreateDBInstance",
-      Version: "2014-10-31",
-      DBInstanceIdentifier: options.DBInstanceIdentifier,
-      DBInstanceClass: options.DBInstanceClass,
-      Engine: options.Engine
-    };
-    if (options.MasterUsername)
-      params.MasterUsername = options.MasterUsername;
-    if (options.MasterUserPassword)
-      params.MasterUserPassword = options.MasterUserPassword;
-    if (options.DBName)
-      params.DBName = options.DBName;
-    if (options.AllocatedStorage)
-      params.AllocatedStorage = options.AllocatedStorage;
-    if (options.DBSubnetGroupName)
-      params.DBSubnetGroupName = options.DBSubnetGroupName;
-    if (options.AvailabilityZone)
-      params.AvailabilityZone = options.AvailabilityZone;
-    if (options.PreferredMaintenanceWindow)
-      params.PreferredMaintenanceWindow = options.PreferredMaintenanceWindow;
-    if (options.PreferredBackupWindow)
-      params.PreferredBackupWindow = options.PreferredBackupWindow;
-    if (options.BackupRetentionPeriod !== undefined)
-      params.BackupRetentionPeriod = options.BackupRetentionPeriod;
-    if (options.MultiAZ !== undefined)
-      params.MultiAZ = options.MultiAZ;
-    if (options.EngineVersion)
-      params.EngineVersion = options.EngineVersion;
-    if (options.AutoMinorVersionUpgrade !== undefined)
-      params.AutoMinorVersionUpgrade = options.AutoMinorVersionUpgrade;
-    if (options.LicenseModel)
-      params.LicenseModel = options.LicenseModel;
-    if (options.PubliclyAccessible !== undefined)
-      params.PubliclyAccessible = options.PubliclyAccessible;
-    if (options.StorageType)
-      params.StorageType = options.StorageType;
-    if (options.StorageEncrypted !== undefined)
-      params.StorageEncrypted = options.StorageEncrypted;
-    if (options.KmsKeyId)
-      params.KmsKeyId = options.KmsKeyId;
-    if (options.DeletionProtection !== undefined)
-      params.DeletionProtection = options.DeletionProtection;
-    if (options.VpcSecurityGroupIds) {
-      options.VpcSecurityGroupIds.forEach((id, i) => {
-        params[`VpcSecurityGroupIds.VpcSecurityGroupId.${i + 1}`] = id;
-      });
+  async describeRules(options) {
+    const params = {};
+    if (options?.ListenerArn) {
+      params.ListenerArn = options.ListenerArn;
     }
-    if (options.Tags) {
-      options.Tags.forEach((tag, i) => {
-        params[`Tags.Tag.${i + 1}.Key`] = tag.Key;
-        params[`Tags.Tag.${i + 1}.Value`] = tag.Value;
+    if (options?.RuleArns) {
+      options.RuleArns.forEach((arn, index) => {
+        params[`RuleArns.member.${index + 1}`] = arn;
       });
     }
-    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
+    if (options?.Marker) {
+      params.Marker = options.Marker;
+    }
+    if (options?.PageSize) {
+      params.PageSize = options.PageSize;
+    }
     const result = await this.client.request({
-      service: "rds",
+      service: "elasticloadbalancing",
       region: this.region,
       method: "POST",
       path: "/",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: queryString
+      body: this.buildFormBody("DescribeRules", params)
     });
-    const response = result.CreateDBInstanceResult || result;
-    return {
-      DBInstance: response.DBInstance
-    };
+    return this.normalizeResult(result, "DescribeRulesResult");
   }
-  async deleteDBInstance(options) {
+  async describeLoadBalancerAttributes(loadBalancerArn) {
     const params = {
-      Action: "DeleteDBInstance",
-      Version: "2014-10-31",
-      DBInstanceIdentifier: options.DBInstanceIdentifier
+      LoadBalancerArn: loadBalancerArn
     };
-    if (options.SkipFinalSnapshot !== undefined) {
-      params.SkipFinalSnapshot = options.SkipFinalSnapshot;
-    }
-    if (options.FinalDBSnapshotIdentifier) {
-      params.FinalDBSnapshotIdentifier = options.FinalDBSnapshotIdentifier;
-    }
-    if (options.DeleteAutomatedBackups !== undefined) {
-      params.DeleteAutomatedBackups = options.DeleteAutomatedBackups;
-    }
-    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
     const result = await this.client.request({
-      service: "rds",
+      service: "elasticloadbalancing",
       region: this.region,
       method: "POST",
       path: "/",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: queryString
+      body: this.buildFormBody("DescribeLoadBalancerAttributes", params)
     });
-    const response = result.DeleteDBInstanceResult || result;
-    return {
-      DBInstance: response.DBInstance
+    return this.normalizeResult(result, "DescribeLoadBalancerAttributesResult");
+  }
+  async describeTargetGroupAttributes(targetGroupArn) {
+    const params = {
+      TargetGroupArn: targetGroupArn
     };
+    const result = await this.client.request({
+      service: "elasticloadbalancing",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: this.buildFormBody("DescribeTargetGroupAttributes", params)
+    });
+    return this.normalizeResult(result, "DescribeTargetGroupAttributesResult");
   }
-  async modifyDBInstance(options) {
+  async createLoadBalancer(options) {
     const params = {
-      Action: "ModifyDBInstance",
-      Version: "2014-10-31",
-      DBInstanceIdentifier: options.DBInstanceIdentifier
+      Name: options.Name
     };
-    if (options.DBInstanceClass)
-      params.DBInstanceClass = options.DBInstanceClass;
-    if (options.AllocatedStorage)
-      params.AllocatedStorage = options.AllocatedStorage;
-    if (options.MasterUserPassword)
-      params.MasterUserPassword = options.MasterUserPassword;
-    if (options.BackupRetentionPeriod !== undefined)
-      params.BackupRetentionPeriod = options.BackupRetentionPeriod;
-    if (options.PreferredBackupWindow)
-      params.PreferredBackupWindow = options.PreferredBackupWindow;
-    if (options.PreferredMaintenanceWindow)
-      params.PreferredMaintenanceWindow = options.PreferredMaintenanceWindow;
-    if (options.MultiAZ !== undefined)
-      params.MultiAZ = options.MultiAZ;
-    if (options.EngineVersion)
-      params.EngineVersion = options.EngineVersion;
-    if (options.AutoMinorVersionUpgrade !== undefined)
-      params.AutoMinorVersionUpgrade = options.AutoMinorVersionUpgrade;
-    if (options.PubliclyAccessible !== undefined)
-      params.PubliclyAccessible = options.PubliclyAccessible;
-    if (options.ApplyImmediately !== undefined)
-      params.ApplyImmediately = options.ApplyImmediately;
-    if (options.StorageType)
-      params.StorageType = options.StorageType;
-    if (options.DeletionProtection !== undefined)
-      params.DeletionProtection = options.DeletionProtection;
-    if (options.VpcSecurityGroupIds) {
-      options.VpcSecurityGroupIds.forEach((id, i) => {
-        params[`VpcSecurityGroupIds.VpcSecurityGroupId.${i + 1}`] = id;
+    if (options.Subnets) {
+      options.Subnets.forEach((subnet, index) => {
+        params[`Subnets.member.${index + 1}`] = subnet;
+      });
+    }
+    if (options.SubnetMappings) {
+      options.SubnetMappings.forEach((mapping, index) => {
+        params[`SubnetMappings.member.${index + 1}.SubnetId`] = mapping.SubnetId;
+        if (mapping.AllocationId) {
+          params[`SubnetMappings.member.${index + 1}.AllocationId`] = mapping.AllocationId;
+        }
+        if (mapping.PrivateIPv4Address) {
+          params[`SubnetMappings.member.${index + 1}.PrivateIPv4Address`] = mapping.PrivateIPv4Address;
+        }
+        if (mapping.IPv6Address) {
+          params[`SubnetMappings.member.${index + 1}.IPv6Address`] = mapping.IPv6Address;
+        }
+      });
+    }
+    if (options.SecurityGroups) {
+      options.SecurityGroups.forEach((sg, index) => {
+        params[`SecurityGroups.member.${index + 1}`] = sg;
+      });
+    }
+    if (options.Scheme) {
+      params.Scheme = options.Scheme;
+    }
+    if (options.Type) {
+      params.Type = options.Type;
+    }
+    if (options.IpAddressType) {
+      params.IpAddressType = options.IpAddressType;
+    }
+    if (options.Tags) {
+      options.Tags.forEach((tag, index) => {
+        params[`Tags.member.${index + 1}.Key`] = tag.Key;
+        params[`Tags.member.${index + 1}.Value`] = tag.Value;
       });
     }
-    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
     const result = await this.client.request({
-      service: "rds",
+      service: "elasticloadbalancing",
       region: this.region,
       method: "POST",
       path: "/",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: queryString
+      body: this.buildFormBody("CreateLoadBalancer", params)
     });
-    const response = result.ModifyDBInstanceResult || result;
-    return {
-      DBInstance: response.DBInstance
-    };
+    return this.normalizeResult(result, "CreateLoadBalancerResult");
   }
-  async startDBInstance(dbInstanceIdentifier) {
+  async deleteLoadBalancer(loadBalancerArn) {
     const params = {
-      Action: "StartDBInstance",
-      Version: "2014-10-31",
-      DBInstanceIdentifier: dbInstanceIdentifier
+      LoadBalancerArn: loadBalancerArn
     };
-    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
-    const result = await this.client.request({
-      service: "rds",
+    await this.client.request({
+      service: "elasticloadbalancing",
       region: this.region,
       method: "POST",
       path: "/",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: queryString
+      body: this.buildFormBody("DeleteLoadBalancer", params)
     });
-    const response = result.StartDBInstanceResult || result;
-    return {
-      DBInstance: response.DBInstance
-    };
   }
-  async stopDBInstance(options) {
+  async createTargetGroup(options) {
     const params = {
-      Action: "StopDBInstance",
-      Version: "2014-10-31",
-      DBInstanceIdentifier: options.DBInstanceIdentifier
+      Name: options.Name
     };
-    if (options.DBSnapshotIdentifier) {
-      params.DBSnapshotIdentifier = options.DBSnapshotIdentifier;
+    if (options.Protocol)
+      params.Protocol = options.Protocol;
+    if (options.ProtocolVersion)
+      params.ProtocolVersion = options.ProtocolVersion;
+    if (options.Port)
+      params.Port = options.Port;
+    if (options.VpcId)
+      params.VpcId = options.VpcId;
+    if (options.HealthCheckProtocol)
+      params.HealthCheckProtocol = options.HealthCheckProtocol;
+    if (options.HealthCheckPort)
+      params.HealthCheckPort = options.HealthCheckPort;
+    if (options.HealthCheckEnabled !== undefined)
+      params.HealthCheckEnabled = options.HealthCheckEnabled;
+    if (options.HealthCheckPath)
+      params.HealthCheckPath = options.HealthCheckPath;
+    if (options.HealthCheckIntervalSeconds)
+      params.HealthCheckIntervalSeconds = options.HealthCheckIntervalSeconds;
+    if (options.HealthCheckTimeoutSeconds)
+      params.HealthCheckTimeoutSeconds = options.HealthCheckTimeoutSeconds;
+    if (options.HealthyThresholdCount)
+      params.HealthyThresholdCount = options.HealthyThresholdCount;
+    if (options.UnhealthyThresholdCount)
+      params.UnhealthyThresholdCount = options.UnhealthyThresholdCount;
+    if (options.TargetType)
+      params.TargetType = options.TargetType;
+    if (options.IpAddressType)
+      params.IpAddressType = options.IpAddressType;
+    if (options.Matcher) {
+      if (options.Matcher.HttpCode)
+        params["Matcher.HttpCode"] = options.Matcher.HttpCode;
+      if (options.Matcher.GrpcCode)
+        params["Matcher.GrpcCode"] = options.Matcher.GrpcCode;
+    }
+    if (options.Tags) {
+      options.Tags.forEach((tag, index) => {
+        params[`Tags.member.${index + 1}.Key`] = tag.Key;
+        params[`Tags.member.${index + 1}.Value`] = tag.Value;
+      });
     }
-    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
     const result = await this.client.request({
-      service: "rds",
+      service: "elasticloadbalancing",
       region: this.region,
       method: "POST",
       path: "/",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: queryString
+      body: this.buildFormBody("CreateTargetGroup", params)
     });
-    const response = result.StopDBInstanceResult || result;
-    return {
-      DBInstance: response.DBInstance
+    return this.normalizeResult(result, "CreateTargetGroupResult");
+  }
+  async deleteTargetGroup(targetGroupArn) {
+    const params = {
+      TargetGroupArn: targetGroupArn
     };
+    await this.client.request({
+      service: "elasticloadbalancing",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: this.buildFormBody("DeleteTargetGroup", params)
+    });
   }
-  async rebootDBInstance(options) {
+  async registerTargets(options) {
     const params = {
-      Action: "RebootDBInstance",
-      Version: "2014-10-31",
-      DBInstanceIdentifier: options.DBInstanceIdentifier
+      TargetGroupArn: options.TargetGroupArn
     };
-    if (options.ForceFailover !== undefined) {
-      params.ForceFailover = options.ForceFailover;
-    }
-    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
-    const result = await this.client.request({
-      service: "rds",
+    options.Targets.forEach((target, index) => {
+      params[`Targets.member.${index + 1}.Id`] = target.Id;
+      if (target.Port) {
+        params[`Targets.member.${index + 1}.Port`] = target.Port;
+      }
+      if (target.AvailabilityZone) {
+        params[`Targets.member.${index + 1}.AvailabilityZone`] = target.AvailabilityZone;
+      }
+    });
+    await this.client.request({
+      service: "elasticloadbalancing",
       region: this.region,
       method: "POST",
       path: "/",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: queryString
+      body: this.buildFormBody("RegisterTargets", params)
     });
-    const response = result.RebootDBInstanceResult || result;
-    return {
-      DBInstance: response.DBInstance
+  }
+  async deregisterTargets(options) {
+    const params = {
+      TargetGroupArn: options.TargetGroupArn
     };
+    options.Targets.forEach((target, index) => {
+      params[`Targets.member.${index + 1}.Id`] = target.Id;
+      if (target.Port) {
+        params[`Targets.member.${index + 1}.Port`] = target.Port;
+      }
+      if (target.AvailabilityZone) {
+        params[`Targets.member.${index + 1}.AvailabilityZone`] = target.AvailabilityZone;
+      }
+    });
+    await this.client.request({
+      service: "elasticloadbalancing",
+      region: this.region,
+      method: "POST",
+      path: "/",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: this.buildFormBody("DeregisterTargets", params)
+    });
   }
-  async createDBSnapshot(options) {
+  async createListener(options) {
     const params = {
-      Action: "CreateDBSnapshot",
-      Version: "2014-10-31",
-      DBInstanceIdentifier: options.DBInstanceIdentifier,
-      DBSnapshotIdentifier: options.DBSnapshotIdentifier
+      LoadBalancerArn: options.LoadBalancerArn,
+      Port: options.Port
     };
+    if (options.Protocol)
+      params.Protocol = options.Protocol;
+    if (options.SslPolicy)
+      params.SslPolicy = options.SslPolicy;
+    if (options.Certificates) {
+      options.Certificates.forEach((cert, index) => {
+        params[`Certificates.member.${index + 1}.CertificateArn`] = cert.CertificateArn;
+      });
+    }
+    options.DefaultActions.forEach((action, index) => {
+      params[`DefaultActions.member.${index + 1}.Type`] = action.Type;
+      if (action.TargetGroupArn) {
+        params[`DefaultActions.member.${index + 1}.TargetGroupArn`] = action.TargetGroupArn;
+      }
+      if (action.Order !== undefined) {
+        params[`DefaultActions.member.${index + 1}.Order`] = action.Order;
+      }
+      if (action.RedirectConfig) {
+        const rc = action.RedirectConfig;
+        if (rc.Protocol)
+          params[`DefaultActions.member.${index + 1}.RedirectConfig.Protocol`] = rc.Protocol;
+        if (rc.Port)
+          params[`DefaultActions.member.${index + 1}.RedirectConfig.Port`] = rc.Port;
+        if (rc.Host)
+          params[`DefaultActions.member.${index + 1}.RedirectConfig.Host`] = rc.Host;
+        if (rc.Path)
+          params[`DefaultActions.member.${index + 1}.RedirectConfig.Path`] = rc.Path;
+        if (rc.Query)
+          params[`DefaultActions.member.${index + 1}.RedirectConfig.Query`] = rc.Query;
+        params[`DefaultActions.member.${index + 1}.RedirectConfig.StatusCode`] = rc.StatusCode;
+      }
+      if (action.FixedResponseConfig) {
+        const fr = action.FixedResponseConfig;
+        if (fr.MessageBody)
+          params[`DefaultActions.member.${index + 1}.FixedResponseConfig.MessageBody`] = fr.MessageBody;
+        params[`DefaultActions.member.${index + 1}.FixedResponseConfig.StatusCode`] = fr.StatusCode;
+        if (fr.ContentType)
+          params[`DefaultActions.member.${index + 1}.FixedResponseConfig.ContentType`] = fr.ContentType;
+      }
+    });
+    if (options.AlpnPolicy) {
+      options.AlpnPolicy.forEach((policy, index) => {
+        params[`AlpnPolicy.member.${index + 1}`] = policy;
+      });
+    }
     if (options.Tags) {
-      options.Tags.forEach((tag, i) => {
-        params[`Tags.Tag.${i + 1}.Key`] = tag.Key;
-        params[`Tags.Tag.${i + 1}.Value`] = tag.Value;
+      options.Tags.forEach((tag, index) => {
+        params[`Tags.member.${index + 1}.Key`] = tag.Key;
+        params[`Tags.member.${index + 1}.Value`] = tag.Value;
       });
     }
-    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
     const result = await this.client.request({
-      service: "rds",
+      service: "elasticloadbalancing",
       region: this.region,
       method: "POST",
       path: "/",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: queryString
+      body: this.buildFormBody("CreateListener", params)
     });
-    const response = result.CreateDBSnapshotResult || result;
-    return {
-      DBSnapshot: response.DBSnapshot
-    };
+    return this.normalizeResult(result, "CreateListenerResult");
   }
-  async deleteDBSnapshot(dbSnapshotIdentifier) {
+  async deleteListener(listenerArn) {
     const params = {
-      Action: "DeleteDBSnapshot",
-      Version: "2014-10-31",
-      DBSnapshotIdentifier: dbSnapshotIdentifier
+      ListenerArn: listenerArn
     };
-    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
-    const result = await this.client.request({
-      service: "rds",
+    await this.client.request({
+      service: "elasticloadbalancing",
       region: this.region,
       method: "POST",
       path: "/",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: queryString
+      body: this.buildFormBody("DeleteListener", params)
     });
-    const response = result.DeleteDBSnapshotResult || result;
-    return {
-      DBSnapshot: response.DBSnapshot
-    };
   }
-  async restoreDBInstanceFromDBSnapshot(options) {
+  async modifyListener(options) {
     const params = {
-      Action: "RestoreDBInstanceFromDBSnapshot",
-      Version: "2014-10-31",
-      DBInstanceIdentifier: options.DBInstanceIdentifier,
-      DBSnapshotIdentifier: options.DBSnapshotIdentifier
+      ListenerArn: options.ListenerArn
     };
-    if (options.DBInstanceClass)
-      params.DBInstanceClass = options.DBInstanceClass;
     if (options.Port)
       params.Port = options.Port;
-    if (options.AvailabilityZone)
-      params.AvailabilityZone = options.AvailabilityZone;
-    if (options.DBSubnetGroupName)
-      params.DBSubnetGroupName = options.DBSubnetGroupName;
-    if (options.MultiAZ !== undefined)
-      params.MultiAZ = options.MultiAZ;
-    if (options.PubliclyAccessible !== undefined)
-      params.PubliclyAccessible = options.PubliclyAccessible;
-    if (options.AutoMinorVersionUpgrade !== undefined)
-      params.AutoMinorVersionUpgrade = options.AutoMinorVersionUpgrade;
-    if (options.StorageType)
-      params.StorageType = options.StorageType;
-    if (options.DeletionProtection !== undefined)
-      params.DeletionProtection = options.DeletionProtection;
-    if (options.VpcSecurityGroupIds) {
-      options.VpcSecurityGroupIds.forEach((id, i) => {
-        params[`VpcSecurityGroupIds.VpcSecurityGroupId.${i + 1}`] = id;
+    if (options.Protocol)
+      params.Protocol = options.Protocol;
+    if (options.SslPolicy)
+      params.SslPolicy = options.SslPolicy;
+    if (options.Certificates) {
+      options.Certificates.forEach((cert, index) => {
+        params[`Certificates.member.${index + 1}.CertificateArn`] = cert.CertificateArn;
       });
     }
-    if (options.Tags) {
-      options.Tags.forEach((tag, i) => {
-        params[`Tags.Tag.${i + 1}.Key`] = tag.Key;
-        params[`Tags.Tag.${i + 1}.Value`] = tag.Value;
+    if (options.DefaultActions) {
+      options.DefaultActions.forEach((action, index) => {
+        if (action.Type)
+          params[`DefaultActions.member.${index + 1}.Type`] = action.Type;
+        if (action.TargetGroupArn)
+          params[`DefaultActions.member.${index + 1}.TargetGroupArn`] = action.TargetGroupArn;
+        if (action.Order !== undefined)
+          params[`DefaultActions.member.${index + 1}.Order`] = action.Order;
+      });
+    }
+    if (options.AlpnPolicy) {
+      options.AlpnPolicy.forEach((policy, index) => {
+        params[`AlpnPolicy.member.${index + 1}`] = policy;
       });
     }
-    const queryString = new URLSearchParams(buildQueryParams(params)).toString();
     const result = await this.client.request({
-      service: "rds",
+      service: "elasticloadbalancing",
       region: this.region,
       method: "POST",
       path: "/",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: queryString
+      body: this.buildFormBody("ModifyListener", params)
     });
-    const response = result.RestoreDBInstanceFromDBSnapshotResult || result;
-    return {
-      DBInstance: response.DBInstance
-    };
+    return this.normalizeResult(result, "ModifyListenerResult");
   }
-  async waitForDBInstanceAvailable(dbInstanceIdentifier, maxAttempts = 60, delayMs = 30000) {
-    for (let i = 0;i < maxAttempts; i++) {
-      const instance = await this.describeDBInstance(dbInstanceIdentifier);
-      if (instance?.DBInstanceStatus === "available") {
-        return instance;
-      }
-      if (["deleted", "failed", "incompatible-restore", "incompatible-parameters"].includes(instance?.DBInstanceStatus || "")) {
-        throw new Error(`DB instance ${dbInstanceIdentifier} is in terminal state: ${instance?.DBInstanceStatus}`);
+  buildFormBody(action, params) {
+    const formParams = {
+      Action: action,
+      Version: "2015-12-01"
+    };
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== undefined && value !== null) {
+        formParams[key] = String(value);
       }
-      await new Promise((resolve14) => setTimeout(resolve14, delayMs));
     }
-    throw new Error(`Timeout waiting for DB instance ${dbInstanceIdentifier} to become available`);
+    return Object.entries(formParams).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
   }
-  async waitForDBInstanceDeleted(dbInstanceIdentifier, maxAttempts = 60, delayMs = 30000) {
-    for (let i = 0;i < maxAttempts; i++) {
-      try {
-        const instance = await this.describeDBInstance(dbInstanceIdentifier);
-        if (instance?.DBInstanceStatus === "deleting") {
-          await new Promise((resolve14) => setTimeout(resolve14, delayMs));
-          continue;
+  normalizeResult(parsed, resultKey) {
+    if (parsed && parsed[resultKey]) {
+      return this.normalizeArrays(parsed[resultKey]);
+    }
+    const responseKey = resultKey.replace("Result", "Response");
+    if (parsed && parsed[responseKey] && parsed[responseKey][resultKey]) {
+      return this.normalizeArrays(parsed[responseKey][resultKey]);
+    }
+    return this.normalizeArrays(parsed);
+  }
+  normalizeArrays(obj) {
+    if (!obj || typeof obj !== "object") {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.normalizeArrays(item));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const arrayFields = [
+        "LoadBalancers",
+        "TargetGroups",
+        "Listeners",
+        "Rules",
+        "TargetHealthDescriptions",
+        "Attributes",
+        "SecurityGroups",
+        "AvailabilityZones",
+        "Certificates",
+        "DefaultActions",
+        "Conditions",
+        "Actions",
+        "member"
+      ];
+      if (key === "member") {
+        if (Array.isArray(value)) {
+          return value.map((item) => this.normalizeArrays(item));
         }
-        throw new Error(`DB instance ${dbInstanceIdentifier} is in state: ${instance?.DBInstanceStatus}`);
-      } catch (error) {
-        if (error.code === "DBInstanceNotFound" || error.code === "DBInstanceNotFoundFault") {
-          return;
+        return [this.normalizeArrays(value)];
+      }
+      if (arrayFields.includes(key)) {
+        if (value && typeof value === "object" && "member" in value) {
+          const memberValue = value.member;
+          result[key] = Array.isArray(memberValue) ? memberValue.map((item) => this.normalizeArrays(item)) : [this.normalizeArrays(memberValue)];
+        } else if (Array.isArray(value)) {
+          result[key] = value.map((item) => this.normalizeArrays(item));
+        } else if (value) {
+          result[key] = [this.normalizeArrays(value)];
+        } else {
+          result[key] = [];
         }
-        throw error;
+      } else if (typeof value === "object") {
+        result[key] = this.normalizeArrays(value);
+      } else {
+        result[key] = value;
       }
     }
-    throw new Error(`Timeout waiting for DB instance ${dbInstanceIdentifier} to be deleted`);
+    return result;
   }
 }
+
+// src/aws/index.ts
+init_rds();
+
 // src/aws/dynamodb.ts
 init_client();