stacktape 2.23.0 → 2.24.0-beta.24

package/index.js

@@ -1,3 +1,3260 @@
-module.exports.sayHello = () => {
-  console.log('Hello, world!');
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api/npm/ts/index.ts
+var index_exports = {};
+__export(index_exports, {
+  $CfFormat: () => $CfFormat,
+  $CfResourceParam: () => $CfResourceParam,
+  $CfStackOutput: () => $CfStackOutput,
+  $GitInfo: () => $GitInfo,
+  $ResourceParam: () => $ResourceParam,
+  $Secret: () => $Secret,
+  AWS_SES: () => AWS_SES,
+  AlarmIntegration: () => AlarmIntegration,
+  ApplicationLoadBalancer: () => ApplicationLoadBalancer,
+  ApplicationLoadBalancerIntegration: () => ApplicationLoadBalancerIntegration,
+  AuroraEngineMysql: () => AuroraEngineMysql,
+  AuroraEnginePostgresql: () => AuroraEnginePostgresql,
+  AuroraServerlessEngineMysql: () => AuroraServerlessEngineMysql,
+  AuroraServerlessEnginePostgresql: () => AuroraServerlessEnginePostgresql,
+  AuroraServerlessV2EngineMysql: () => AuroraServerlessV2EngineMysql,
+  AuroraServerlessV2EnginePostgresql: () => AuroraServerlessV2EnginePostgresql,
+  BaseResource: () => BaseResource,
+  BaseTypeProperties: () => BaseTypeProperties,
+  Bastion: () => Bastion,
+  BastionScriptWithCommand: () => BastionScriptWithCommand,
+  BastionScriptWithCommands: () => BastionScriptWithCommands,
+  BatchJob: () => BatchJob,
+  Bucket: () => Bucket,
+  CdnBucketRoute: () => CdnBucketRoute,
+  CdnCustomDomainRoute: () => CdnCustomDomainRoute,
+  CdnHttpApiGatewayRoute: () => CdnHttpApiGatewayRoute,
+  CdnLambdaFunctionRoute: () => CdnLambdaFunctionRoute,
+  CdnLoadBalancerRoute: () => CdnLoadBalancerRoute,
+  CloudwatchLogIntegration: () => CloudwatchLogIntegration,
+  ContainerEfsMount: () => ContainerEfsMount,
+  ContainerWorkload: () => ContainerWorkload,
+  ContainerWorkloadHttpApiIntegration: () => ContainerWorkloadHttpApiIntegration,
+  ContainerWorkloadInternalIntegration: () => ContainerWorkloadInternalIntegration,
+  ContainerWorkloadServiceConnectIntegration: () => ContainerWorkloadServiceConnectIntegration,
+  CustomArtifactLambdaPackaging: () => CustomArtifactLambdaPackaging,
+  CustomDockerfilePackaging: () => CustomDockerfilePackaging,
+  CustomRuleGroup: () => CustomRuleGroup,
+  DatadogLogForwarding: () => DatadogLogForwarding,
+  DynamoDbIntegration: () => DynamoDbIntegration,
+  DynamoDbTable: () => DynamoDbTable,
+  EfsFilesystem: () => EfsFilesystem,
+  EventBus: () => EventBus,
+  EventBusIntegration: () => EventBusIntegration,
+  ExpirationLifecycleRule: () => ExpirationLifecycleRule,
+  ExternalBuildpackPackaging: () => ExternalBuildpackPackaging,
+  HighlightLogForwarding: () => HighlightLogForwarding,
+  HostingBucket: () => HostingBucket,
+  HttpApiGateway: () => HttpApiGateway,
+  HttpApiIntegration: () => HttpApiIntegration,
+  HttpEndpointLogForwarding: () => HttpEndpointLogForwarding,
+  KafkaTopicIntegration: () => KafkaTopicIntegration,
+  KinesisIntegration: () => KinesisIntegration,
+  LambdaEfsMount: () => LambdaEfsMount,
+  LambdaFunction: () => LambdaFunction,
+  LocalScriptWithBastionTunnelingCommand: () => LocalScriptWithBastionTunnelingCommand,
+  LocalScriptWithBastionTunnelingCommands: () => LocalScriptWithBastionTunnelingCommands,
+  LocalScriptWithBastionTunnelingFileScript: () => LocalScriptWithBastionTunnelingFileScript,
+  LocalScriptWithBastionTunnelingFileScripts: () => LocalScriptWithBastionTunnelingFileScripts,
+  LocalScriptWithCommand: () => LocalScriptWithCommand,
+  LocalScriptWithCommands: () => LocalScriptWithCommands,
+  LocalScriptWithFileScript: () => LocalScriptWithFileScript,
+  LocalScriptWithFileScripts: () => LocalScriptWithFileScripts,
+  ManagedRuleGroup: () => ManagedRuleGroup,
+  MongoDbAtlasCluster: () => MongoDbAtlasCluster,
+  NetworkLoadBalancer: () => NetworkLoadBalancer,
+  NextjsWeb: () => NextjsWeb,
+  NixpacksPackaging: () => NixpacksPackaging,
+  NonCurrentVersionExpirationLifecycleRule: () => NonCurrentVersionExpirationLifecycleRule,
+  OpenSearchDomain: () => OpenSearchDomain,
+  PrebuiltImagePackaging: () => PrebuiltImagePackaging,
+  PrivateService: () => PrivateService,
+  RateBasedRule: () => RateBasedRule,
+  RdsEngineMariadb: () => RdsEngineMariadb,
+  RdsEngineMysql: () => RdsEngineMysql,
+  RdsEngineOracleEE: () => RdsEngineOracleEE,
+  RdsEngineOracleSE2: () => RdsEngineOracleSE2,
+  RdsEnginePostgres: () => RdsEnginePostgres,
+  RdsEngineSqlServerEE: () => RdsEngineSqlServerEE,
+  RdsEngineSqlServerEX: () => RdsEngineSqlServerEX,
+  RdsEngineSqlServerSE: () => RdsEngineSqlServerSE,
+  RdsEngineSqlServerWeb: () => RdsEngineSqlServerWeb,
+  RedisCluster: () => RedisCluster,
+  RelationalDatabase: () => RelationalDatabase,
+  ResourceParamReference: () => ResourceParamReference,
+  S3Integration: () => S3Integration,
+  ScheduleIntegration: () => ScheduleIntegration,
+  SnsIntegration: () => SnsIntegration,
+  SnsTopic: () => SnsTopic,
+  SqsIntegration: () => SqsIntegration,
+  SqsQueue: () => SqsQueue,
+  SqsQueueEventBusIntegration: () => SqsQueueEventBusIntegration,
+  StacktapeImageBuildpackPackaging: () => StacktapeImageBuildpackPackaging,
+  StacktapeLambdaBuildpackPackaging: () => StacktapeLambdaBuildpackPackaging,
+  StateMachine: () => StateMachine,
+  UpstashRedis: () => UpstashRedis,
+  UserAuthPool: () => UserAuthPool,
+  WebAppFirewall: () => WebAppFirewall,
+  WebService: () => WebService,
+  WorkerService: () => WorkerService,
+  defineConfig: () => defineConfig,
+  transformConfigWithResources: () => transformConfigWithResources,
+  transformValue: () => transformValue
+});
+module.exports = __toCommonJS(index_exports);
+
+// node_modules/change-case/dist/index.js
+var SPLIT_LOWER_UPPER_RE = new RegExp("([\\p{Ll}\\d])(\\p{Lu})", "gu");
+var SPLIT_UPPER_UPPER_RE = new RegExp("(\\p{Lu})([\\p{Lu}][\\p{Ll}])", "gu");
+var SPLIT_SEPARATE_NUMBER_RE = new RegExp("(\\d)\\p{Ll}|(\\p{L})\\d", "u");
+var DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+var SPLIT_REPLACE_VALUE = "$1\0$2";
+var DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+function split(value) {
+  let result = value.trim();
+  result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+  result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+  let start = 0;
+  let end = result.length;
+  while (result.charAt(start) === "\0")
+    start++;
+  if (start === end)
+    return [];
+  while (result.charAt(end - 1) === "\0")
+    end--;
+  return result.slice(start, end).split(/\0/g);
+}
+__name(split, "split");
+function splitSeparateNumbers(value) {
+  const words = split(value);
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i];
+    const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
+    if (match) {
+      const offset = match.index + (match[1] ?? match[2]).length;
+      words.splice(i, 1, word.slice(0, offset), word.slice(offset));
+    }
+  }
+  return words;
+}
+__name(splitSeparateNumbers, "splitSeparateNumbers");
+function pascalCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  const lower = lowerFactory(options?.locale);
+  const upper = upperFactory(options?.locale);
+  const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+  return prefix + words.map(transform).join(options?.delimiter ?? "") + suffix;
+}
+__name(pascalCase, "pascalCase");
+function lowerFactory(locale) {
+  return locale === false ? (input) => input.toLowerCase() : (input) => input.toLocaleLowerCase(locale);
+}
+__name(lowerFactory, "lowerFactory");
+function upperFactory(locale) {
+  return locale === false ? (input) => input.toUpperCase() : (input) => input.toLocaleUpperCase(locale);
+}
+__name(upperFactory, "upperFactory");
+function capitalCaseTransformFactory(lower, upper) {
+  return (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+}
+__name(capitalCaseTransformFactory, "capitalCaseTransformFactory");
+function pascalCaseTransformFactory(lower, upper) {
+  return (word, index) => {
+    const char0 = word[0];
+    const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
+    return initial + lower(word.slice(1));
+  };
+}
+__name(pascalCaseTransformFactory, "pascalCaseTransformFactory");
+function splitPrefixSuffix(input, options = {}) {
+  const splitFn = options.split ?? (options.separateNumbers ? splitSeparateNumbers : split);
+  const prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  const suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  let prefixIndex = 0;
+  let suffixIndex = input.length;
+  while (prefixIndex < input.length) {
+    const char = input.charAt(prefixIndex);
+    if (!prefixCharacters.includes(char))
+      break;
+    prefixIndex++;
+  }
+  while (suffixIndex > prefixIndex) {
+    const index = suffixIndex - 1;
+    const char = input.charAt(index);
+    if (!suffixCharacters.includes(char))
+      break;
+    suffixIndex = index;
+  }
+  return [
+    input.slice(0, prefixIndex),
+    splitFn(input.slice(prefixIndex, suffixIndex)),
+    input.slice(suffixIndex)
+  ];
+}
+__name(splitPrefixSuffix, "splitPrefixSuffix");
+
+// shared/naming/logical-names.ts
+var cfLogicalNames = {
+  bucket(stpResourceName) {
+    return pascalCase(`${stpResourceName}-bucket`);
+  },
+  atlasMongoProject() {
+    return buildCfLogicalName({
+      specifier: { type: "AtlasMongo" },
+      suffix: { cloudformationResourceType: "MongoDB::StpAtlasV1::Project" }
+    });
+  },
+  atlasMongoCredentialsProvider() {
+    return buildCfLogicalName({
+      specifier: { type: "AtlasMongoCredentialsProvider" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  atlasMongoProjectVpcNetworkContainer() {
+    return buildCfLogicalName({
+      specifier: { type: "AtlasMongo" },
+      suffix: { cloudformationResourceType: "MongoDB::StpAtlasV1::NetworkContainer" }
+    });
+  },
+  atlasMongoProjectVpcNetworkPeering() {
+    return buildCfLogicalName({
+      specifier: { type: "AtlasMongo" },
+      suffix: { cloudformationResourceType: "MongoDB::StpAtlasV1::NetworkPeering" }
+    });
+  },
+  atlasMongoProjectIpAccessList() {
+    return buildCfLogicalName({
+      specifier: { type: "AtlasMongo" },
+      suffix: { cloudformationResourceType: "MongoDB::StpAtlasV1::ProjectIpAccessList" }
+    });
+  },
+  atlasMongoUserAssociatedWithRole(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "AtlasMongo" },
+      suffix: { cloudformationResourceType: "MongoDB::StpAtlasV1::DatabaseUser" }
+    });
+  },
+  atlasMongoClusterMasterUser(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "MongoDB::StpAtlasV1::DatabaseUser" }
+    });
+  },
+  atlasMongoCluster(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "MongoDB::StpAtlasV1::Cluster" }
+    });
+  },
+  redisReplicationGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ElastiCache::ReplicationGroup" }
+    });
+  },
+  redisLogGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::Logs::LogGroup" }
+    });
+  },
+  redisParameterGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ElastiCache::ParameterGroup" }
+    });
+  },
+  redisSubnetGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ElastiCache::SubnetGroup" }
+    });
+  },
+  redisSecurityGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::EC2::SecurityGroup" }
+    });
+  },
+  efsFilesystem(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: {
+        cloudformationResourceType: "AWS::EFS::FileSystem"
+      }
+    });
+  },
+  efsAccessPoint({
+    stpResourceName,
+    efsFilesystemName,
+    rootDirectory
+  }) {
+    const rootDirIdentifier = rootDirectory ? `${rootDirectory.replace(/\//g, "-").replace(/^-|-$/g, "")}` : "Root";
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: {
+        type: `${efsFilesystemName}-${rootDirIdentifier}`
+      },
+      suffix: {
+        cloudformationResourceType: "AWS::EFS::AccessPoint"
+      }
+    });
+  },
+  efsMountTarget(stpResourceName, mountTargetIndex) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "Subnet", typeIndex: mountTargetIndex },
+      suffix: { cloudformationResourceType: "AWS::EFS::MountTarget" }
+    });
+  },
+  efsSecurityGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::EC2::SecurityGroup" }
+    });
+  },
+  snsRoleSendSmsFromCognito(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "SendSms" },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  cloudfrontDistribution(stpResourceName, distributionIndex) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "CDN" },
+      suffix: { cloudformationResourceType: "AWS::CloudFront::Distribution", index: distributionIndex }
+    });
+  },
+  cloudfrontCustomCachePolicy(stpResourceName, cachingOptionsHash) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: `CDNCacheBehavior${cachingOptionsHash}` },
+      suffix: { cloudformationResourceType: "AWS::CloudFront::CachePolicy" }
+    });
+  },
+  cloudfrontDefaultCachePolicy(type) {
+    return buildCfLogicalName({
+      specifier: { type: `CDN${type}` },
+      suffix: { cloudformationResourceType: "AWS::CloudFront::CachePolicy" }
+    });
+  },
+  cloudfrontCustomOriginRequestPolicy(stpResourceName, forwardingOptionsHash) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: `CDNCacheBehavior${forwardingOptionsHash}` },
+      suffix: { cloudformationResourceType: "AWS::CloudFront::OriginRequestPolicy" }
+    });
+  },
+  cloudfrontDefaultOriginRequestPolicy(type) {
+    return buildCfLogicalName({
+      specifier: { type: `CDN${type}` },
+      suffix: { cloudformationResourceType: "AWS::CloudFront::OriginRequestPolicy" }
+    });
+  },
+  cloudfrontOriginAccessIdentity(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "CDN" },
+      suffix: { cloudformationResourceType: "AWS::CloudFront::CloudFrontOriginAccessIdentity" }
+    });
+  },
+  openNextHostHeaderRewriteFunction(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "OpenNextHostHeaderRewrite" },
+      suffix: { cloudformationResourceType: "AWS::CloudFront::Function" }
+    });
+  },
+  openNextAssetReplacerCustomResource(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "AssetReplacer" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  openNextDynamoInsertCustomResource(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "DynamoInsert" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  dnsRecord(fullyQualifiedDomainName) {
+    return buildCfLogicalName({
+      stpResourceName: "",
+      specifier: { type: getSpecifierForDomainResource(fullyQualifiedDomainName) },
+      suffix: { cloudformationResourceType: "AWS::Route53::RecordSet" }
+    });
+  },
+  dynamoGlobalTable(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::DynamoDB::GlobalTable" }
+    });
+  },
+  dynamoRegionalTable(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::DynamoDB::Table" }
+    });
+  },
+  bucketPolicy(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::S3::BucketPolicy" }
+    });
+  },
+  lambdaLogGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::Logs::LogGroup" }
+    });
+  },
+  eventOnDeliveryFailureSqsQueuePolicy(stpResourceName, eventIndex) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: {
+        type: "Event",
+        typeIndex: eventIndex
+      },
+      suffix: { cloudformationResourceType: "AWS::SQS::QueuePolicy" }
+    });
+  },
+  snsEventSubscription(stpResourceName, eventIndex) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: {
+        type: "Event",
+        typeIndex: eventIndex
+      },
+      suffix: { cloudformationResourceType: "AWS::SNS::Subscription" }
+    });
+  },
+  snsEventPermission(stpResourceName, eventIndex) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: {
+        type: "Event",
+        typeIndex: eventIndex
+      },
+      suffix: { cloudformationResourceType: "AWS::Lambda::Permission" }
+    });
+  },
+  ecrRepo() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "Container"
+      },
+      suffix: { cloudformationResourceType: "AWS::ECR::Repository" }
+    });
+  },
+  deploymentBucket() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "Deployment"
+      },
+      suffix: { cloudformationResourceType: "AWS::S3::Bucket" }
+    });
+  },
+  deploymentBucketPolicy() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "Deployment"
+      },
+      suffix: { cloudformationResourceType: "AWS::S3::BucketPolicy" }
+    });
+  },
+  lambdaInvokeConfig(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::Lambda::EventInvokeConfig" }
+    });
+  },
+  lambdaVersionPublisherCustomResource(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "Version" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  codeDeployServiceRole() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "CodeDeploy"
+      },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  batchInstanceRole() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "BatchInstance"
+      },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  batchInstanceDefaultSecurityGroup() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "BatchInstance"
+      },
+      suffix: { cloudformationResourceType: "AWS::EC2::SecurityGroup" }
+    });
+  },
+  batchInstanceProfile() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "BatchInstance"
+      },
+      suffix: { cloudformationResourceType: "AWS::IAM::InstanceProfile" }
+    });
+  },
+  batchInstanceLaunchTemplate() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "BatchInstance"
+      },
+      suffix: { cloudformationResourceType: "AWS::EC2::LaunchTemplate" }
+    });
+  },
+  batchStateMachineExecutionRole() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "BatchStateMachine"
+      },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  batchSpotFleetRole() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "BatchSpotFleet"
+      },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  batchServiceRole() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "BatchService"
+      },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  batchJobExecutionRole(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  batchComputeEnvironment(spot, gpu) {
+    return buildCfLogicalName({
+      specifier: {
+        type: `Batch-${spot ? "spot" : "onDemand"}-${gpu ? "gpu" : ""}`
+      },
+      suffix: { cloudformationResourceType: "AWS::Batch::ComputeEnvironment" }
+    });
+  },
+  batchJobQueue(spot, gpu) {
+    return buildCfLogicalName({
+      specifier: {
+        type: `Batch-${spot ? "spot" : "onDemand"}-${gpu ? "gpu" : ""}`
+      },
+      suffix: { cloudformationResourceType: "AWS::Batch::JobQueue" }
+    });
+  },
+  subnet(publicSubnet, subnetIndex) {
+    return buildCfLogicalName({
+      specifier: {
+        type: publicSubnet ? "Public" : "Private"
+      },
+      suffix: { cloudformationResourceType: "AWS::EC2::Subnet", index: subnetIndex }
+    });
+  },
+  vpc() {
+    return buildCfLogicalName({
+      suffix: { cloudformationResourceType: "AWS::EC2::VPC" }
+    });
+  },
+  vpcGatewayEndpoint(type) {
+    return buildCfLogicalName({
+      specifier: { type: `${type}-Gateway` },
+      suffix: { cloudformationResourceType: "AWS::EC2::VPCEndpoint" }
+    });
+  },
+  dbSubnetGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::RDS::DBSubnetGroup" }
+    });
+  },
+  auroraDbCluster(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::RDS::DBCluster" }
+    });
+  },
+  auroraDbClusterParameterGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::RDS::DBClusterParameterGroup" }
+    });
+  },
+  auroraDbClusterLogGroup(stpResourceName, logGroupType) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "Cluster", subtype: logGroupType },
+      suffix: { cloudformationResourceType: "AWS::Logs::LogGroup" }
+    });
+  },
+  dbSecurityGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::EC2::SecurityGroup" }
+    });
+  },
+  dbInstance(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::RDS::DBInstance" }
+    });
+  },
+  dbInstanceLogGroup(stpResourceName, logGroupType) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "Instance", subtype: logGroupType },
+      suffix: { cloudformationResourceType: "AWS::Logs::LogGroup" }
+    });
+  },
+  openSearchDomainLogGroup(stpResourceName, logGroupType) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "Instance", subtype: logGroupType },
+      suffix: { cloudformationResourceType: "AWS::Logs::LogGroup" }
+    });
+  },
+  dbOptionGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::RDS::OptionGroup" }
+    });
+  },
+  dbInstanceParameterGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::RDS::DBParameterGroup" }
+    });
+  },
+  dbReplica(stpResourceName, replicaNum) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "Replica", typeIndex: replicaNum },
+      suffix: { cloudformationResourceType: "AWS::RDS::DBInstance" }
+    });
+  },
+  dbReplicaLogGroup(stpResourceName, logGroupType, replicaNum) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "Replica", typeIndex: replicaNum, subtype: logGroupType },
+      suffix: { cloudformationResourceType: "AWS::Logs::LogGroup" }
+    });
+  },
+  dbReplicaParameterGroup(stpResourceName, replicaNum) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "Replica", typeIndex: replicaNum },
+      suffix: { cloudformationResourceType: "AWS::RDS::DBParameterGroup" }
+    });
+  },
+  auroraDbInstance(stpResourceName, instanceNum) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::RDS::DBInstance", index: instanceNum }
+    });
+  },
+  auroraDbInstanceParameterGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "Instance" },
+      suffix: { cloudformationResourceType: "AWS::RDS::DBParameterGroup" }
+    });
+  },
+  eventBusRule(stpResourceName, eventIndex) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: {
+        type: "Event",
+        typeIndex: eventIndex
+      },
+      suffix: { cloudformationResourceType: "AWS::Events::Rule" }
+    });
+  },
+  customTaggingScheduleRule() {
+    return buildCfLogicalName({
+      specifier: { type: "StpCustomTaggingSchedule" },
+      suffix: { cloudformationResourceType: "AWS::Events::Rule" }
+    });
+  },
+  customTaggingScheduleRulePermission() {
+    return buildCfLogicalName({
+      specifier: { type: "StpCustomTaggingScheduleRule" },
+      suffix: { cloudformationResourceType: "AWS::Lambda::Permission" }
+    });
+  },
+  cloudWatchLogEventSubscriptionFilter(stpResourceName, eventIndex) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: {
+        type: "Event",
+        typeIndex: eventIndex
+      },
+      suffix: { cloudformationResourceType: "AWS::Logs::SubscriptionFilter" }
+    });
+  },
+  eventSourceMapping(stpResourceName, eventIndex) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: {
+        type: "Event",
+        typeIndex: eventIndex
+      },
+      suffix: { cloudformationResourceType: "AWS::Lambda::EventSourceMapping" }
+    });
+  },
+  iotEventTopicRule(stpResourceName, eventIndex) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: {
+        type: "Event",
+        typeIndex: eventIndex
+      },
+      suffix: { cloudformationResourceType: "AWS::IoT::TopicRule" }
+    });
+  },
+  kinesisEventConsumer(stpResourceName, eventIndex) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: {
+        type: "Event",
+        typeIndex: eventIndex
+      },
+      suffix: { cloudformationResourceType: "AWS::Kinesis::StreamConsumer" }
+    });
+  },
+  lambda(stpResourceName, isStpServiceFunction) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: isStpServiceFunction ? { type: "CustomResource" } : void 0,
+      suffix: { cloudformationResourceType: "AWS::Lambda::Function" }
+    });
+  },
+  lambdaStpAlias(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: {
+        type: "Stp"
+      },
+      suffix: { cloudformationResourceType: "AWS::Lambda::Alias" }
+    });
+  },
+  lambdaUrl(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::Lambda::Url" }
+    });
+  },
+  codeDeployDeploymentGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::CodeDeploy::DeploymentGroup" }
+    });
+  },
+  customResource(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  scriptCustomResource(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "Script" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  batchStateMachine(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "JobExecution" },
+      suffix: { cloudformationResourceType: "AWS::StepFunctions::StateMachine" }
+    });
+  },
+  batchJobDefinition(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::Batch::JobDefinition" }
+    });
+  },
+  batchJobLogGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::Logs::LogGroup" }
+    });
+  },
+  globalStateMachinesRole() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "GlobalStateMachine"
+      },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  stateMachine(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::StepFunctions::StateMachine" }
+    });
+  },
+  internetGateway() {
+    return buildCfLogicalName({
+      suffix: { cloudformationResourceType: "AWS::EC2::InternetGateway" }
+    });
+  },
+  vpcGatewayAttachment() {
+    return buildCfLogicalName({
+      suffix: { cloudformationResourceType: "AWS::EC2::VPCGatewayAttachment" }
+    });
+  },
+  routeTable(publicSubnet, subnetIndex) {
+    return buildCfLogicalName({
+      specifier: { type: publicSubnet ? "PublicSubnet" : "PrivateSubnet", typeIndex: subnetIndex },
+      suffix: { cloudformationResourceType: "AWS::EC2::RouteTable" }
+    });
+  },
+  internetGatewayRoute(subnetIndex) {
+    return buildCfLogicalName({
+      specifier: { type: "InternetGateway" },
+      suffix: { cloudformationResourceType: "AWS::EC2::Route", index: subnetIndex }
+    });
+  },
+  atlasMongoVpcRoute(publicSubnetTable, subnetIndex) {
+    return buildCfLogicalName({
+      specifier: { type: `AtlasMongo${publicSubnetTable ? "PublicSubnet" : "PrivateSubnet"}` },
+      suffix: { cloudformationResourceType: "AWS::EC2::Route", index: subnetIndex }
+    });
+  },
+  routeTableToSubnetAssociation(publicSubnet, subnetIndex) {
+    return buildCfLogicalName({
+      specifier: { type: publicSubnet ? "PublicSubnet" : "PrivateSubnet", typeIndex: subnetIndex },
+      suffix: { cloudformationResourceType: "AWS::EC2::SubnetRouteTableAssociation" }
+    });
+  },
+  natGateway(azIndex) {
+    return buildCfLogicalName({
+      suffix: { cloudformationResourceType: "AWS::EC2::NatGateway", index: azIndex }
+    });
+  },
+  natElasticIp(azIndex) {
+    return buildCfLogicalName({
+      specifier: { type: "Nat" },
+      suffix: { cloudformationResourceType: "AWS::EC2::EIP", index: azIndex }
+    });
+  },
+  natRoute(subnetIndex) {
+    return buildCfLogicalName({
+      specifier: { type: "NatPrivateSubnet" },
+      suffix: { cloudformationResourceType: "AWS::EC2::Route", index: subnetIndex }
+    });
+  },
+  eventBus(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::Events::EventBus" }
+    });
+  },
+  eventBusArchive(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::Events::Archive" }
+    });
+  },
+  ecsCluster(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ECS::Cluster" }
+    });
+  },
+  ecsTaskDefinition(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ECS::TaskDefinition" }
+    });
+  },
+  ecsService(stpResourceName, blueGreen) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: blueGreen ? { type: "BlueGreen" } : void 0,
+      suffix: { cloudformationResourceType: "AWS::ECS::Service" }
+    });
+  },
+  ecsExecutionRole() {
+    return buildCfLogicalName({
+      specifier: { type: "EcsExecution" },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  ecsEc2InstanceRole() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "EcsInstance"
+      },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  ecsEc2AutoscalingGroupWarmPool(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::AutoScaling::WarmPool" }
+    });
+  },
+  eventBusRoleForScheduledInstanceRefresh() {
+    return buildCfLogicalName({
+      specifier: { type: "ScheduledInstanceRefresh" },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  schedulerRuleForScheduledInstanceRefresh(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "ScheduledInstanceRefresh" },
+      suffix: { cloudformationResourceType: "AWS::Events::Rule" }
+    });
+  },
+  ecsEc2InstanceLaunchTemplate(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::EC2::LaunchTemplate" }
+    });
+  },
+  ecsEc2AutoscalingGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::AutoScaling::AutoScalingGroup" }
+    });
+  },
+  ecsEc2ForceDeleteAutoscalingGroupCustomResource(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "ForceDeleteAsg" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  ecsDisableManagedTerminationProtectionCustomResource(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "DisableManagedTerminationProtection" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  ecsEc2CapacityProvider(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ECS::CapacityProvider" }
+    });
+  },
+  ecsEc2CapacityProviderAssociation(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ECS::ClusterCapacityProviderAssociations" }
+    });
+  },
+  ecsEc2InstanceProfile() {
+    return buildCfLogicalName({
+      specifier: {
+        type: "EcsInstance"
+      },
+      suffix: { cloudformationResourceType: "AWS::IAM::InstanceProfile" }
+    });
+  },
+  ecsTaskRole(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  ecsAutoScalingRole() {
+    return buildCfLogicalName({
+      specifier: { type: "EcsAutoScale" },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  // ecsScheduledMaintenanceEventBusRule(stpResourceName: string) {
+  //   return buildCfLogicalName({
+  //     stpResourceName,
+  //     specifier: { type: 'ScheduledMaintenance' },
+  //     suffix: { cloudformationResourceType: 'AWS::Events::Rule' }
+  //   }).replaceAll('_', '');
+  // },
+  ecsScheduledMaintenanceLambdaPermission(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "ScheduledMaintenance" },
+      suffix: { cloudformationResourceType: "AWS::Lambda::Permission" }
+    }).replaceAll("_", "");
+  },
+  bastionEc2LaunchTemplate(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::EC2::LaunchTemplate" }
+    });
+  },
+  bastionEc2InstanceProfile(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::IAM::InstanceProfile" }
+    });
+  },
+  bastionEc2AutoscalingGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::AutoScaling::AutoScalingGroup" }
+    });
+  },
+  bastionSecurityGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::EC2::SecurityGroup" }
+    });
+  },
+  bastionCwAgentSsmAssociation(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "CwAgent" },
+      suffix: { cloudformationResourceType: "AWS::SSM::Association" }
+    });
+  },
+  bastionSsmAgentSsmAssociation(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "SsmAgent" },
+      suffix: { cloudformationResourceType: "AWS::SSM::Association" }
+    });
+  },
+  bastionRole(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  bastionLogGroup(stpResourceName, logType) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: pascalCase(logType) },
+      suffix: { cloudformationResourceType: "AWS::Logs::LogGroup" }
+    });
+  },
+  bastionCloudwatchSsmDocument() {
+    return buildCfLogicalName({
+      specifier: { type: "BastionCloudwatchAgent" },
+      suffix: { cloudformationResourceType: "AWS::SSM::Document" }
+    });
+  },
+  serviceDiscoveryEcsService(stpResourceName, serviceTargetContainerPort) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: `Port${serviceTargetContainerPort}Discovery` },
+      suffix: { cloudformationResourceType: "AWS::ServiceDiscovery::Service" }
+    });
+  },
+  workloadSecurityGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::EC2::SecurityGroup" }
+    });
+  },
+  loadBalancerSecurityGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "Lb" },
+      suffix: { cloudformationResourceType: "AWS::EC2::SecurityGroup" }
+    });
+  },
+  targetGroup({
+    loadBalancerName,
+    stpResourceName,
+    targetContainerPort,
+    blueGreen
+  }) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: {
+        type: `${loadBalancerName}${targetContainerPort ? `ToPort${targetContainerPort}` : ""}${blueGreen ? "BG" : ""}`
+      },
+      suffix: { cloudformationResourceType: "AWS::ElasticLoadBalancingV2::TargetGroup" }
+    });
+  },
+  lambdaRole(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  defaultLambdaFunctionRole() {
+    return buildCfLogicalName({
+      specifier: { type: "Lambda" },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  lambdaPermission(stpResourceName, eventIndex) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "Event", typeIndex: eventIndex },
+      suffix: { cloudformationResourceType: "AWS::Lambda::Permission" }
+    });
+  },
+  lambdaPublicUrlPermission(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "PublicUrl" },
+      suffix: { cloudformationResourceType: "AWS::Lambda::Permission" }
+    });
+  },
+  lambdaIotEventPermission(workloadName, eventIndex) {
+    return pascalCase(`${workloadName}-Event${eventIndex}-lambda-iotEventPermission`);
+  },
+  lambdaTargetGroupPermission(stpResourceName, loadBalancerName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: `${loadBalancerName}TargetGroup` },
+      suffix: { cloudformationResourceType: "AWS::Lambda::Permission" }
+    });
+  },
+  httpApi(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ApiGatewayV2::Api" }
+    });
+  },
+  httpApiLogGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::Logs::LogGroup" }
+    });
+  },
+  httpApiLambdaIntegration({
+    stpResourceName,
+    stpHttpApiGatewayName
+  }) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: stpHttpApiGatewayName },
+      suffix: { cloudformationResourceType: "AWS::ApiGatewayV2::Integration" }
+    });
+  },
+  httpApiContainerWorkloadIntegration({
+    stpResourceName,
+    stpHttpApiGatewayName,
+    targetContainerPort
+  }) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: `${stpHttpApiGatewayName}ToPort${targetContainerPort}` },
+      suffix: { cloudformationResourceType: "AWS::ApiGatewayV2::Integration" }
+    });
+  },
+  httpApiAuthorizer({ method, path, stpResourceName }) {
+    return buildCfLogicalName({
+      stpResourceName: "",
+      specifier: {
+        type: `${stpResourceName}-${method === "*" ? "Any" : method}-${path === "*" ? "Default" : path}`
+      },
+      suffix: { cloudformationResourceType: "AWS::ApiGatewayV2::Authorizer" }
+    });
+  },
+  httpApiRoute({ method, path, stpResourceName }) {
+    return buildCfLogicalName({
+      stpResourceName: "",
+      specifier: {
+        type: `${stpResourceName}-${method === "*" ? "Any" : method}-${path === "*" ? "Default" : path}`
+      },
+      suffix: { cloudformationResourceType: "AWS::ApiGatewayV2::Route" }
+    });
+  },
+  httpApiVpcLink(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ApiGatewayV2::VpcLink" }
+    });
+  },
+  httpApiVpcLinkSecurityGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "VpcLink" },
+      suffix: { cloudformationResourceType: "AWS::EC2::SecurityGroup" }
+    });
+  },
+  httpApiLambdaPermission({
+    stpResourceNameOfLambda,
+    stpResourceNameOfHttpApiGateway
+  }) {
+    return buildCfLogicalName({
+      stpResourceName: stpResourceNameOfLambda,
+      specifier: { type: stpResourceNameOfHttpApiGateway },
+      suffix: { cloudformationResourceType: "AWS::Lambda::Permission" }
+    });
+  },
+  httpApiStage(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ApiGatewayV2::Stage" }
+    });
+  },
+  httpApiDomain(fullyQualifiedDomainName) {
+    return buildCfLogicalName({
+      stpResourceName: "",
+      specifier: { type: getSpecifierForDomainResource(fullyQualifiedDomainName) },
+      suffix: { cloudformationResourceType: "AWS::ApiGatewayV2::DomainName" }
+    });
+  },
+  httpApiDefaultDomain(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ApiGatewayV2::DomainName" }
+    });
+  },
+  httpApiDomainMapping(fullyQualifiedDomainName) {
+    return buildCfLogicalName({
+      stpResourceName: "",
+      specifier: { type: getSpecifierForDomainResource(fullyQualifiedDomainName) },
+      suffix: { cloudformationResourceType: "AWS::ApiGatewayV2::ApiMapping" }
+    });
+  },
+  httpApiDefaultDomainMapping(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ApiGatewayV2::ApiMapping" }
+    });
+  },
+  listener(exposurePort, stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: `Port${exposurePort}` },
+      suffix: { cloudformationResourceType: "AWS::ElasticLoadBalancingV2::Listener" }
+    });
+  },
+  listenerRule(exposurePort, stpResourceName, rulePriority) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: `Port${exposurePort}Priority${rulePriority}` },
+      suffix: { cloudformationResourceType: "AWS::ElasticLoadBalancingV2::ListenerRule" }
+    });
+  },
+  listenerCertificateList(exposurePort, stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: `Port${exposurePort}` },
+      suffix: { cloudformationResourceType: "AWS::ElasticLoadBalancingV2::ListenerCertificate" }
+    });
+  },
+  loadBalancer(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ElasticLoadBalancingV2::LoadBalancer" }
+    });
+  },
+  ecsLogGroup(stpResourceName, containerName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: containerName },
+      suffix: { cloudformationResourceType: "AWS::Logs::LogGroup" }
+    });
+  },
+  autoScalingTarget(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::ApplicationAutoScaling::ScalableTarget" }
+    });
+  },
+  dynamoAutoScalingTarget(stpResourceName, metric) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: metric },
+      suffix: { cloudformationResourceType: "AWS::ApplicationAutoScaling::ScalableTarget" }
+    });
+  },
+  autoScalingPolicy(stpResourceName, metric) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: metric },
+      suffix: { cloudformationResourceType: "AWS::ApplicationAutoScaling::ScalingPolicy" }
+    });
+  },
+  customResourceS3Events() {
+    return buildCfLogicalName({
+      specifier: { type: "Events" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  // @deprecated
+  // stacktapeServiceCustomResourceEdgeFunctions() {
+  //   return buildCfLogicalName({
+  //     specifier: { type: 'EdgeFunctions' },
+  //     suffix: { cloudformationResourceType: 'AWS::CloudFormation::CustomResource' }
+  //   });
+  // },
+  customResourceSensitiveData() {
+    return buildCfLogicalName({
+      specifier: { type: "SensitiveData" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  customResourceAcceptVpcPeerings() {
+    return buildCfLogicalName({
+      specifier: { type: "AcceptVpcPeerings" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  customResourceDefaultDomainCert() {
+    return buildCfLogicalName({
+      specifier: { type: "DefaultDomainCert" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  customResourceEdgeLambdaBucket() {
+    return buildCfLogicalName({
+      specifier: { type: "EdgeLambdaBucket" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  customResourceEdgeLambda(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "EdgeLambda" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  customResourceDefaultDomain(stpResourceName, cdn) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: `${cdn ? "Cdn" : ""}DefaultDomain` },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  customResourceDatabaseDeletionProtection(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "DeletionProtection" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  userPool(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::Cognito::UserPool" }
+    });
+  },
+  userPoolClient(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::Cognito::UserPoolClient" }
+    });
+  },
+  userPoolDomain(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::Cognito::UserPoolDomain" }
+    });
+  },
+  identityProvider(stpResourceName, type) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type },
+      suffix: { cloudformationResourceType: "AWS::Cognito::UserPoolIdentityProvider" }
+    });
+  },
+  cognitoLambdaHookPermission(stpResourceName, hookName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: hookName },
+      suffix: { cloudformationResourceType: "AWS::Lambda::Permission" }
+    });
+  },
+  cognitoUserPoolDetailsCustomResource(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "UserPoolDetails" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  userPoolUiCustomizationAttachment(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::Cognito::UserPoolUICustomizationAttachment" }
+    });
+  },
+  serviceDiscoveryPrivateNamespace() {
+    return buildCfLogicalName({
+      specifier: { type: "Discovery" },
+      suffix: { cloudformationResourceType: "AWS::ServiceDiscovery::Service" }
+    });
+  },
+  lambdaCodeDeployApp() {
+    return buildCfLogicalName({
+      specifier: { type: "LambdaCodeDeploy" },
+      suffix: { cloudformationResourceType: "AWS::CodeDeploy::Application" }
+    });
+  },
+  ecsCodeDeployApp() {
+    return buildCfLogicalName({
+      specifier: { type: "ECSCodeDeploy" },
+      suffix: { cloudformationResourceType: "AWS::CodeDeploy::Application" }
+    });
+  },
+  stackBudget(stackName) {
+    return buildCfLogicalName({
+      specifier: { type: pascalCase(stackName).replaceAll("_", "") },
+      suffix: { cloudformationResourceType: "AWS::Budgets::Budget" }
+    });
+  },
+  upstashRedisDatabase(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "Upstash::DatabasesV1::Database" }
+    });
+  },
+  upstashCredentialsProvider() {
+    return buildCfLogicalName({
+      specifier: { type: "UpstashCredentialsProvider" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  cloudwatchAlarm(stacktapeAlarmName) {
+    return buildCfLogicalName({
+      stpResourceName: stacktapeAlarmName,
+      suffix: { cloudformationResourceType: "AWS::CloudWatch::Alarm" }
+    }).replaceAll("_", "");
+  },
+  cloudwatchAlarmEventBusNotificationRule(stacktapeAlarmName) {
+    return buildCfLogicalName({
+      stpResourceName: stacktapeAlarmName,
+      specifier: { type: "Notification" },
+      suffix: { cloudformationResourceType: "AWS::Events::Rule" }
+    }).replaceAll("_", "");
+  },
+  cloudwatchAlarmEventBusNotificationRuleLambdaPermission(stacktapeAlarmName) {
+    return buildCfLogicalName({
+      stpResourceName: stacktapeAlarmName,
+      specifier: { type: "Notification" },
+      suffix: { cloudformationResourceType: "AWS::Lambda::Permission" }
+    }).replaceAll("_", "");
+  },
+  sqsQueue(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::SQS::Queue" }
+    }).replaceAll("_", "");
+  },
+  sqsQueuePolicy(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::SQS::QueuePolicy" }
+    });
+  },
+  snsTopic(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::SNS::Topic" }
+    }).replaceAll("_", "");
+  },
+  webAppFirewallCustomResource(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "WebAppFirewall" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  webAppFirewallAssociation(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::WAFv2::WebACLAssociation" }
+    });
+  },
+  openSearchDomain(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::OpenSearchService::Domain" }
+    });
+  },
+  openSearchCustomResource(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "OpenSearch" },
+      suffix: { cloudformationResourceType: "AWS::CloudFormation::CustomResource" }
+    });
+  },
+  openSearchSecurityGroup(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      suffix: { cloudformationResourceType: "AWS::EC2::SecurityGroup" }
+    });
+  },
+  logForwardingFirehoseToS3Role(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "LogForwardingS3" },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  logForwardingCwToFirehoseRole({ logGroupCfLogicalName }) {
+    return buildCfLogicalName({
+      stpResourceName: logGroupCfLogicalName,
+      specifier: { type: "CwToFirehose" },
+      suffix: { cloudformationResourceType: "AWS::IAM::Role" }
+    });
+  },
+  logForwardingFailedEventsBucket(stpResourceName) {
+    return buildCfLogicalName({
+      stpResourceName,
+      specifier: { type: "LogForwardingFailedRecords" },
+      suffix: { cloudformationResourceType: "AWS::S3::Bucket" }
+    });
+  },
+  logForwardingFirehoseDeliveryStream({ logGroupCfLogicalName }) {
+    return buildCfLogicalName({
+      stpResourceName: logGroupCfLogicalName,
+      suffix: { cloudformationResourceType: "AWS::KinesisFirehose::DeliveryStream" }
+    });
+  },
+  logForwardingSubscriptionFilter({ logGroupCfLogicalName }) {
+    return buildCfLogicalName({
+      stpResourceName: logGroupCfLogicalName,
+      suffix: { cloudformationResourceType: "AWS::Logs::SubscriptionFilter" }
+    });
+  }
+};
+var buildCfLogicalName = /* @__PURE__ */ __name(({
+  stpResourceName,
+  specifier,
+  suffix
+}) => {
+  const splittedType = suffix.cloudformationResourceType.split(":");
+  const resolvedParentName = stpResourceName || "Stp";
+  const resolvedSpecifier = specifier ? `${specifier.type}${specifier.typeIndex !== void 0 ? specifier.typeIndex : ""}${specifier.subtype !== void 0 ? `-${specifier.subtype}` : ""}` : "";
+  const resolvedSuffix = `${splittedType[splittedType.length - 1]}${suffix.index !== void 0 ? suffix.index : ""}`;
+  return pascalCase(`${resolvedParentName}-${resolvedSpecifier}-${resolvedSuffix}`);
+}, "buildCfLogicalName");
+var getSpecifierForDomainResource = /* @__PURE__ */ __name((fullyQualifiedDomainName) => {
+  if (pascalCase(fullyQualifiedDomainName).replace("_", "").length < 85) {
+    return pascalCase(fullyQualifiedDomainName).replace("_", "");
+  }
+  const splittedDomain = fullyQualifiedDomainName.split(".").map((subdomain) => subdomain.split("-")).flat();
+  const maxCharactersPerWord = Math.floor(85 / splittedDomain.length);
+  return splittedDomain.map((word) => pascalCase(word.slice(0, maxCharactersPerWord)).replace("_", "")).join("");
+}, "getSpecifierForDomainResource");
+
+// src/api/npm/ts/child-resources.ts
+var CHILD_RESOURCES = {
+  // ===== BUCKET =====
+  bucket: [
+    { logicalName: cfLogicalNames.bucket, resourceType: "AWS::S3::Bucket" },
+    { logicalName: cfLogicalNames.bucketPolicy, resourceType: "AWS::S3::BucketPolicy", conditional: true },
+    {
+      logicalName: cfLogicalNames.cloudfrontOriginAccessIdentity,
+      resourceType: "AWS::CloudFront::CloudFrontOriginAccessIdentity",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDistribution,
+      resourceType: "AWS::CloudFront::Distribution",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.customResourceDefaultDomain,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.dnsRecord, resourceType: "AWS::Route53::RecordSet", conditional: true }
+  ],
+  // ===== FUNCTION =====
+  function: [
+    { logicalName: cfLogicalNames.lambdaRole, resourceType: "AWS::IAM::Role" },
+    { logicalName: cfLogicalNames.lambda, resourceType: "AWS::Lambda::Function" },
+    { logicalName: cfLogicalNames.efsAccessPoint, resourceType: "AWS::EFS::AccessPoint", conditional: true },
+    { logicalName: cfLogicalNames.workloadSecurityGroup, resourceType: "AWS::EC2::SecurityGroup", conditional: true },
+    { logicalName: cfLogicalNames.lambdaUrl, resourceType: "AWS::Lambda::Url", conditional: true },
+    {
+      logicalName: cfLogicalNames.lambdaPublicUrlPermission,
+      resourceType: "AWS::Lambda::Permission",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.lambdaLogGroup, resourceType: "AWS::Logs::LogGroup", conditional: true },
+    {
+      logicalName: cfLogicalNames.lambdaInvokeConfig,
+      resourceType: "AWS::Lambda::EventInvokeConfig",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.lambdaCodeDeployApp,
+      resourceType: "AWS::CodeDeploy::Application",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.lambdaVersionPublisherCustomResource,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.codeDeployDeploymentGroup,
+      resourceType: "AWS::CodeDeploy::DeploymentGroup",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.lambdaStpAlias, resourceType: "AWS::Lambda::Alias", conditional: true },
+    {
+      logicalName: cfLogicalNames.cloudfrontOriginAccessIdentity,
+      resourceType: "AWS::CloudFront::CloudFrontOriginAccessIdentity",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true,
+      unresolvable: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true,
+      unresolvable: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDistribution,
+      resourceType: "AWS::CloudFront::Distribution",
+      conditional: true,
+      unresolvable: true
+    },
+    {
+      logicalName: cfLogicalNames.customResourceDefaultDomain,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.dnsRecord, resourceType: "AWS::Route53::RecordSet", conditional: true },
+    {
+      logicalName: cfLogicalNames.lambdaPermission,
+      resourceType: "AWS::Lambda::Permission",
+      conditional: true,
+      unresolvable: true
+    }
+  ],
+  // ===== RELATIONAL DATABASE =====
+  "relational-database": [
+    { logicalName: cfLogicalNames.dbSubnetGroup, resourceType: "AWS::RDS::DBSubnetGroup" },
+    { logicalName: cfLogicalNames.dbSecurityGroup, resourceType: "AWS::EC2::SecurityGroup" },
+    {
+      logicalName: cfLogicalNames.customResourceDatabaseDeletionProtection,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.auroraDbCluster, resourceType: "AWS::RDS::DBCluster", conditional: true },
+    {
+      logicalName: cfLogicalNames.auroraDbClusterParameterGroup,
+      resourceType: "AWS::RDS::DBClusterParameterGroup",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.auroraDbClusterLogGroup,
+      resourceType: "AWS::Logs::LogGroup",
+      conditional: true,
+      unresolvable: true
+    },
+    {
+      logicalName: cfLogicalNames.auroraDbInstance,
+      resourceType: "AWS::RDS::DBInstance",
+      conditional: true,
+      unresolvable: true
+    },
+    {
+      logicalName: cfLogicalNames.auroraDbInstanceParameterGroup,
+      resourceType: "AWS::RDS::DBParameterGroup",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.dbInstance, resourceType: "AWS::RDS::DBInstance", conditional: true },
+    {
+      logicalName: cfLogicalNames.dbInstanceLogGroup,
+      resourceType: "AWS::Logs::LogGroup",
+      conditional: true,
+      unresolvable: true
+    },
+    { logicalName: cfLogicalNames.dbOptionGroup, resourceType: "AWS::RDS::OptionGroup", conditional: true },
+    {
+      logicalName: cfLogicalNames.dbInstanceParameterGroup,
+      resourceType: "AWS::RDS::DBParameterGroup",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.dbReplica,
+      resourceType: "AWS::RDS::DBInstance",
+      conditional: true,
+      unresolvable: true
+    },
+    {
+      logicalName: cfLogicalNames.dbReplicaLogGroup,
+      resourceType: "AWS::Logs::LogGroup",
+      conditional: true,
+      unresolvable: true
+    }
+  ],
+  // ===== DYNAMO DB TABLE =====
+  "dynamo-db-table": [{ logicalName: cfLogicalNames.dynamoGlobalTable, resourceType: "AWS::DynamoDB::GlobalTable" }],
+  // ===== HTTP API GATEWAY =====
+  "http-api-gateway": [
+    { logicalName: cfLogicalNames.httpApi, resourceType: "AWS::ApiGatewayV2::Api" },
+    { logicalName: cfLogicalNames.httpApiStage, resourceType: "AWS::ApiGatewayV2::Stage" },
+    { logicalName: cfLogicalNames.httpApiLogGroup, resourceType: "AWS::Logs::LogGroup", conditional: true },
+    {
+      logicalName: cfLogicalNames.httpApiVpcLinkSecurityGroup,
+      resourceType: "AWS::EC2::SecurityGroup",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.httpApiVpcLink, resourceType: "AWS::ApiGatewayV2::VpcLink", conditional: true },
+    { logicalName: cfLogicalNames.httpApiDomain, resourceType: "AWS::ApiGatewayV2::DomainName", conditional: true },
+    {
+      logicalName: cfLogicalNames.httpApiDomainMapping,
+      resourceType: "AWS::ApiGatewayV2::ApiMapping",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.httpApiDefaultDomain,
+      resourceType: "AWS::ApiGatewayV2::DomainName",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.httpApiDefaultDomainMapping,
+      resourceType: "AWS::ApiGatewayV2::ApiMapping",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.customResourceDefaultDomain,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.dnsRecord, resourceType: "AWS::Route53::RecordSet", conditional: true },
+    {
+      logicalName: cfLogicalNames.cloudfrontOriginAccessIdentity,
+      resourceType: "AWS::CloudFront::CloudFrontOriginAccessIdentity",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDistribution,
+      resourceType: "AWS::CloudFront::Distribution",
+      conditional: true
+    }
+  ],
+  // ===== BATCH JOB =====
+  "batch-job": [
+    { logicalName: cfLogicalNames.batchServiceRole, resourceType: "AWS::IAM::Role", conditional: true },
+    { logicalName: cfLogicalNames.batchSpotFleetRole, resourceType: "AWS::IAM::Role", conditional: true },
+    { logicalName: cfLogicalNames.batchInstanceRole, resourceType: "AWS::IAM::Role", conditional: true },
+    { logicalName: cfLogicalNames.batchInstanceProfile, resourceType: "AWS::IAM::InstanceProfile", conditional: true },
+    { logicalName: cfLogicalNames.batchStateMachineExecutionRole, resourceType: "AWS::IAM::Role", conditional: true },
+    {
+      logicalName: cfLogicalNames.batchInstanceLaunchTemplate,
+      resourceType: "AWS::EC2::LaunchTemplate",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.batchInstanceDefaultSecurityGroup,
+      resourceType: "AWS::EC2::SecurityGroup",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.batchComputeEnvironment,
+      resourceType: "AWS::Batch::ComputeEnvironment",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.batchJobQueue, resourceType: "AWS::Batch::JobQueue", conditional: true },
+    { logicalName: cfLogicalNames.batchJobDefinition, resourceType: "AWS::Batch::JobDefinition" },
+    { logicalName: cfLogicalNames.batchStateMachine, resourceType: "AWS::StepFunctions::StateMachine" },
+    { logicalName: cfLogicalNames.batchJobLogGroup, resourceType: "AWS::Logs::LogGroup", conditional: true },
+    { logicalName: cfLogicalNames.batchJobExecutionRole, resourceType: "AWS::IAM::Role" },
+    {
+      logicalName: cfLogicalNames.atlasMongoUserAssociatedWithRole,
+      resourceType: "MongoDB::StpAtlasV1::DatabaseUser",
+      conditional: true
+    }
+  ],
+  // ===== EVENT BUS =====
+  "event-bus": [
+    { logicalName: cfLogicalNames.eventBus, resourceType: "AWS::Events::EventBus" },
+    { logicalName: cfLogicalNames.eventBusArchive, resourceType: "AWS::Events::Archive", conditional: true }
+  ],
+  // ===== STATE MACHINE =====
+  "state-machine": [
+    { logicalName: cfLogicalNames.globalStateMachinesRole, resourceType: "AWS::IAM::Role", conditional: true },
+    { logicalName: cfLogicalNames.stateMachine, resourceType: "AWS::StepFunctions::StateMachine" }
+  ],
+  // ===== REDIS CLUSTER =====
+  "redis-cluster": [
+    { logicalName: cfLogicalNames.redisParameterGroup, resourceType: "AWS::ElastiCache::ParameterGroup" },
+    { logicalName: cfLogicalNames.redisSubnetGroup, resourceType: "AWS::ElastiCache::SubnetGroup" },
+    { logicalName: cfLogicalNames.redisSecurityGroup, resourceType: "AWS::EC2::SecurityGroup" },
+    { logicalName: cfLogicalNames.redisLogGroup, resourceType: "AWS::Logs::LogGroup", conditional: true },
+    { logicalName: cfLogicalNames.redisReplicationGroup, resourceType: "AWS::ElastiCache::ReplicationGroup" }
+  ],
+  // ===== MONGO DB ATLAS CLUSTER =====
+  "mongo-db-atlas-cluster": [
+    {
+      logicalName: cfLogicalNames.atlasMongoCredentialsProvider,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.atlasMongoProject, resourceType: "MongoDB::StpAtlasV1::Project", conditional: true },
+    {
+      logicalName: cfLogicalNames.atlasMongoProjectIpAccessList,
+      resourceType: "MongoDB::StpAtlasV1::ProjectIpAccessList",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.atlasMongoProjectVpcNetworkContainer,
+      resourceType: "MongoDB::StpAtlasV1::NetworkContainer",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.atlasMongoProjectVpcNetworkPeering,
+      resourceType: "MongoDB::StpAtlasV1::NetworkPeering",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.atlasMongoVpcRoute, resourceType: "AWS::EC2::Route", conditional: true },
+    { logicalName: cfLogicalNames.atlasMongoCluster, resourceType: "MongoDB::StpAtlasV1::Cluster" },
+    {
+      logicalName: cfLogicalNames.atlasMongoClusterMasterUser,
+      resourceType: "MongoDB::StpAtlasV1::DatabaseUser",
+      conditional: true
+    }
+  ],
+  // ===== USER AUTH POOL =====
+  "user-auth-pool": [
+    { logicalName: cfLogicalNames.userPool, resourceType: "AWS::Cognito::UserPool" },
+    { logicalName: cfLogicalNames.snsRoleSendSmsFromCognito, resourceType: "AWS::IAM::Role" },
+    { logicalName: cfLogicalNames.userPoolClient, resourceType: "AWS::Cognito::UserPoolClient" },
+    { logicalName: cfLogicalNames.userPoolDomain, resourceType: "AWS::Cognito::UserPoolDomain" },
+    {
+      logicalName: cfLogicalNames.cognitoUserPoolDetailsCustomResource,
+      resourceType: "AWS::CloudFormation::CustomResource"
+    },
+    {
+      logicalName: cfLogicalNames.identityProvider,
+      resourceType: "AWS::Cognito::UserPoolIdentityProvider",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cognitoLambdaHookPermission,
+      resourceType: "AWS::Lambda::Permission",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.userPoolUiCustomizationAttachment,
+      resourceType: "AWS::Cognito::UserPoolUICustomizationAttachment",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.webAppFirewallAssociation,
+      resourceType: "AWS::WAFv2::WebACLAssociation",
+      conditional: true
+    }
+  ],
+  // ===== UPSTASH REDIS =====
+  "upstash-redis": [
+    {
+      logicalName: cfLogicalNames.upstashCredentialsProvider,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.upstashRedisDatabase, resourceType: "Upstash::Redis::Database" }
+  ],
+  // ===== APPLICATION LOAD BALANCER =====
+  "application-load-balancer": [
+    { logicalName: cfLogicalNames.loadBalancer, resourceType: "AWS::ElasticLoadBalancingV2::LoadBalancer" },
+    { logicalName: cfLogicalNames.loadBalancerSecurityGroup, resourceType: "AWS::EC2::SecurityGroup" },
+    {
+      logicalName: cfLogicalNames.webAppFirewallAssociation,
+      resourceType: "AWS::WAFv2::WebACLAssociation",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.listener, resourceType: "AWS::ElasticLoadBalancingV2::Listener", conditional: true },
+    {
+      logicalName: cfLogicalNames.customResourceDefaultDomain,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.dnsRecord, resourceType: "AWS::Route53::RecordSet", conditional: true },
+    {
+      logicalName: cfLogicalNames.cloudfrontOriginAccessIdentity,
+      resourceType: "AWS::CloudFront::CloudFrontOriginAccessIdentity",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDistribution,
+      resourceType: "AWS::CloudFront::Distribution",
+      conditional: true
+    }
+  ],
+  // ===== NETWORK LOAD BALANCER =====
+  "network-load-balancer": [
+    { logicalName: cfLogicalNames.loadBalancer, resourceType: "AWS::ElasticLoadBalancingV2::LoadBalancer" },
+    { logicalName: cfLogicalNames.loadBalancerSecurityGroup, resourceType: "AWS::EC2::SecurityGroup" },
+    { logicalName: cfLogicalNames.listener, resourceType: "AWS::ElasticLoadBalancingV2::Listener", conditional: true },
+    {
+      logicalName: cfLogicalNames.customResourceDefaultDomain,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.dnsRecord, resourceType: "AWS::Route53::RecordSet", conditional: true }
+  ],
+  // ===== HOSTING BUCKET =====
+  // Hosting bucket delegates to a bucket resource, so it includes all bucket child resources
+  "hosting-bucket": [
+    { logicalName: cfLogicalNames.bucket, resourceType: "AWS::S3::Bucket" },
+    { logicalName: cfLogicalNames.bucketPolicy, resourceType: "AWS::S3::BucketPolicy", conditional: true },
+    {
+      logicalName: cfLogicalNames.cloudfrontOriginAccessIdentity,
+      resourceType: "AWS::CloudFront::CloudFrontOriginAccessIdentity",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDistribution,
+      resourceType: "AWS::CloudFront::Distribution",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.customResourceDefaultDomain,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.dnsRecord, resourceType: "AWS::Route53::RecordSet", conditional: true }
+  ],
+  // ===== WEB APP FIREWALL =====
+  "web-app-firewall": [
+    { logicalName: cfLogicalNames.webAppFirewallCustomResource, resourceType: "AWS::CloudFormation::CustomResource" }
+  ],
+  // ===== OPEN SEARCH DOMAIN =====
+  "open-search-domain": [
+    { logicalName: cfLogicalNames.openSearchDomain, resourceType: "AWS::OpenSearchService::Domain" },
+    { logicalName: cfLogicalNames.openSearchSecurityGroup, resourceType: "AWS::EC2::SecurityGroup", conditional: true },
+    {
+      logicalName: cfLogicalNames.openSearchDomainLogGroup,
+      resourceType: "AWS::Logs::LogGroup",
+      conditional: true,
+      unresolvable: true
+    },
+    {
+      logicalName: cfLogicalNames.openSearchCustomResource,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    }
+  ],
+  // ===== EFS FILESYSTEM =====
+  "efs-filesystem": [
+    { logicalName: cfLogicalNames.efsFilesystem, resourceType: "AWS::EFS::FileSystem" },
+    { logicalName: cfLogicalNames.efsSecurityGroup, resourceType: "AWS::EC2::SecurityGroup" },
+    {
+      logicalName: cfLogicalNames.efsMountTarget,
+      resourceType: "AWS::EFS::MountTarget",
+      unresolvable: true
+    }
+  ],
+  // ===== NEXTJS WEB =====
+  // NextJS web delegates to: bucket, imageFunction, revalidationFunction, revalidationQueue,
+  // revalidationTable, revalidationInsertFunction, and optionally serverEdgeFunction or serverFunction
+  "nextjs-web": [
+    // NextJS-specific resources
+    {
+      logicalName: cfLogicalNames.openNextHostHeaderRewriteFunction,
+      resourceType: "AWS::CloudFront::Function"
+    },
+    {
+      logicalName: cfLogicalNames.openNextAssetReplacerCustomResource,
+      resourceType: "AWS::CloudFormation::CustomResource"
+    },
+    {
+      logicalName: cfLogicalNames.openNextDynamoInsertCustomResource,
+      resourceType: "AWS::CloudFormation::CustomResource"
+    },
+    // From bucket
+    { logicalName: cfLogicalNames.bucket, resourceType: "AWS::S3::Bucket" },
+    { logicalName: cfLogicalNames.bucketPolicy, resourceType: "AWS::S3::BucketPolicy", conditional: true },
+    {
+      logicalName: cfLogicalNames.cloudfrontOriginAccessIdentity,
+      resourceType: "AWS::CloudFront::CloudFrontOriginAccessIdentity",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDistribution,
+      resourceType: "AWS::CloudFront::Distribution",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.customResourceDefaultDomain,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.dnsRecord, resourceType: "AWS::Route53::RecordSet", conditional: true },
+    // From functions (imageFunction, revalidationFunction, serverFunction, warmerFunction, revalidationInsertFunction)
+    { logicalName: cfLogicalNames.lambdaRole, resourceType: "AWS::IAM::Role" },
+    { logicalName: cfLogicalNames.lambda, resourceType: "AWS::Lambda::Function" },
+    { logicalName: cfLogicalNames.lambdaLogGroup, resourceType: "AWS::Logs::LogGroup", conditional: true },
+    { logicalName: cfLogicalNames.lambdaUrl, resourceType: "AWS::Lambda::Url", conditional: true },
+    // From edge function (serverEdgeFunction)
+    {
+      logicalName: cfLogicalNames.customResourceEdgeLambda,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    // From revalidationQueue
+    { logicalName: cfLogicalNames.sqsQueue, resourceType: "AWS::SQS::Queue" },
+    { logicalName: cfLogicalNames.sqsQueuePolicy, resourceType: "AWS::SQS::QueuePolicy", conditional: true },
+    // From revalidationTable
+    { logicalName: cfLogicalNames.dynamoGlobalTable, resourceType: "AWS::DynamoDB::GlobalTable" }
+  ],
+  // ===== MULTI-CONTAINER WORKLOAD =====
+  "multi-container-workload": [
+    // Shared global resources (conditional - created only once if not exists)
+    { logicalName: cfLogicalNames.ecsExecutionRole, resourceType: "AWS::IAM::Role", conditional: true },
+    { logicalName: cfLogicalNames.ecsAutoScalingRole, resourceType: "AWS::IAM::Role", conditional: true },
+    // Scaling resources (conditional - only if scaling is configured)
+    {
+      logicalName: cfLogicalNames.autoScalingTarget,
+      resourceType: "AWS::ApplicationAutoScaling::ScalableTarget",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.autoScalingPolicy,
+      resourceType: "AWS::ApplicationAutoScaling::ScalingPolicy",
+      conditional: true,
+      unresolvable: true
+    },
+    // EC2-based resources (conditional - only if instanceTypes are configured)
+    { logicalName: cfLogicalNames.ecsEc2InstanceRole, resourceType: "AWS::IAM::Role", conditional: true },
+    {
+      logicalName: cfLogicalNames.eventBusRoleForScheduledInstanceRefresh,
+      resourceType: "AWS::IAM::Role",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.ecsEc2InstanceProfile, resourceType: "AWS::IAM::InstanceProfile", conditional: true },
+    {
+      logicalName: cfLogicalNames.ecsEc2InstanceLaunchTemplate,
+      resourceType: "AWS::EC2::LaunchTemplate",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2AutoscalingGroup,
+      resourceType: "AWS::AutoScaling::AutoScalingGroup",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2ForceDeleteAutoscalingGroupCustomResource,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2CapacityProvider,
+      resourceType: "AWS::ECS::CapacityProvider",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2CapacityProviderAssociation,
+      resourceType: "AWS::ECS::ClusterCapacityProviderAssociations",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.schedulerRuleForScheduledInstanceRefresh,
+      resourceType: "AWS::Scheduler::Schedule",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2AutoscalingGroupWarmPool,
+      resourceType: "AWS::AutoScaling::WarmPool",
+      conditional: true
+    },
+    // Deployment resources (conditional - only if deployment is configured)
+    { logicalName: cfLogicalNames.ecsCodeDeployApp, resourceType: "AWS::CodeDeploy::Application", conditional: true },
+    {
+      logicalName: cfLogicalNames.codeDeployDeploymentGroup,
+      resourceType: "AWS::CodeDeploy::DeploymentGroup",
+      conditional: true
+    },
+    // Core resources (always present)
+    { logicalName: cfLogicalNames.ecsCluster, resourceType: "AWS::ECS::Cluster" },
+    { logicalName: cfLogicalNames.workloadSecurityGroup, resourceType: "AWS::EC2::SecurityGroup" },
+    {
+      logicalName: cfLogicalNames.ecsService,
+      resourceType: "AWS::ECS::Service",
+      unresolvable: true
+    },
+    { logicalName: cfLogicalNames.ecsTaskRole, resourceType: "AWS::IAM::Role" },
+    { logicalName: cfLogicalNames.ecsTaskDefinition, resourceType: "AWS::ECS::TaskDefinition" },
+    // Conditional resources
+    {
+      logicalName: cfLogicalNames.ecsLogGroup,
+      resourceType: "AWS::Logs::LogGroup",
+      conditional: true,
+      unresolvable: true
+    },
+    { logicalName: cfLogicalNames.efsAccessPoint, resourceType: "AWS::EFS::AccessPoint", conditional: true },
+    {
+      logicalName: cfLogicalNames.atlasMongoUserAssociatedWithRole,
+      resourceType: "MongoDB::StpAtlasV1::DatabaseUser",
+      conditional: true
+    }
+  ],
+  // ===== SQS QUEUE =====
+  "sqs-queue": [
+    { logicalName: cfLogicalNames.sqsQueue, resourceType: "AWS::SQS::Queue" },
+    { logicalName: cfLogicalNames.sqsQueuePolicy, resourceType: "AWS::SQS::QueuePolicy", conditional: true }
+  ],
+  // ===== SNS TOPIC =====
+  "sns-topic": [{ logicalName: cfLogicalNames.snsTopic, resourceType: "AWS::SNS::Topic" }],
+  // ===== BASTION =====
+  bastion: [
+    {
+      logicalName: cfLogicalNames.bastionCloudwatchSsmDocument,
+      resourceType: "AWS::SSM::Document",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.bastionEc2AutoscalingGroup, resourceType: "AWS::AutoScaling::AutoScalingGroup" },
+    { logicalName: cfLogicalNames.bastionSecurityGroup, resourceType: "AWS::EC2::SecurityGroup" },
+    { logicalName: cfLogicalNames.bastionEc2LaunchTemplate, resourceType: "AWS::EC2::LaunchTemplate" },
+    { logicalName: cfLogicalNames.bastionRole, resourceType: "AWS::IAM::Role" },
+    { logicalName: cfLogicalNames.bastionEc2InstanceProfile, resourceType: "AWS::IAM::InstanceProfile" },
+    { logicalName: cfLogicalNames.bastionCwAgentSsmAssociation, resourceType: "AWS::SSM::Association" },
+    { logicalName: cfLogicalNames.bastionSsmAgentSsmAssociation, resourceType: "AWS::SSM::Association" },
+    {
+      logicalName: cfLogicalNames.bastionLogGroup,
+      resourceType: "AWS::Logs::LogGroup",
+      conditional: true,
+      unresolvable: true
+    }
+  ],
+  // ===== EDGE LAMBDA FUNCTION =====
+  "edge-lambda-function": [
+    { logicalName: cfLogicalNames.customResourceEdgeLambda, resourceType: "AWS::CloudFormation::CustomResource" }
+  ],
+  // ===== WEB SERVICE =====
+  // Web service delegates to: containerWorkload + optionally (httpApiGateway OR loadBalancer OR networkLoadBalancer)
+  "web-service": [
+    // From multi-container-workload - core resources (always present)
+    { logicalName: cfLogicalNames.ecsCluster, resourceType: "AWS::ECS::Cluster" },
+    { logicalName: cfLogicalNames.workloadSecurityGroup, resourceType: "AWS::EC2::SecurityGroup" },
+    {
+      logicalName: cfLogicalNames.ecsService,
+      resourceType: "AWS::ECS::Service",
+      unresolvable: true
+    },
+    { logicalName: cfLogicalNames.ecsTaskRole, resourceType: "AWS::IAM::Role" },
+    { logicalName: cfLogicalNames.ecsTaskDefinition, resourceType: "AWS::ECS::TaskDefinition" },
+    // From multi-container-workload - conditional resources
+    { logicalName: cfLogicalNames.ecsExecutionRole, resourceType: "AWS::IAM::Role", conditional: true },
+    { logicalName: cfLogicalNames.ecsAutoScalingRole, resourceType: "AWS::IAM::Role", conditional: true },
+    {
+      logicalName: cfLogicalNames.autoScalingTarget,
+      resourceType: "AWS::ApplicationAutoScaling::ScalableTarget",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.autoScalingPolicy,
+      resourceType: "AWS::ApplicationAutoScaling::ScalingPolicy",
+      conditional: true,
+      unresolvable: true
+    },
+    { logicalName: cfLogicalNames.ecsEc2InstanceRole, resourceType: "AWS::IAM::Role", conditional: true },
+    {
+      logicalName: cfLogicalNames.eventBusRoleForScheduledInstanceRefresh,
+      resourceType: "AWS::IAM::Role",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.ecsEc2InstanceProfile, resourceType: "AWS::IAM::InstanceProfile", conditional: true },
+    {
+      logicalName: cfLogicalNames.ecsEc2InstanceLaunchTemplate,
+      resourceType: "AWS::EC2::LaunchTemplate",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2AutoscalingGroup,
+      resourceType: "AWS::AutoScaling::AutoScalingGroup",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2ForceDeleteAutoscalingGroupCustomResource,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2CapacityProvider,
+      resourceType: "AWS::ECS::CapacityProvider",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2CapacityProviderAssociation,
+      resourceType: "AWS::ECS::ClusterCapacityProviderAssociations",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.schedulerRuleForScheduledInstanceRefresh,
+      resourceType: "AWS::Scheduler::Schedule",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2AutoscalingGroupWarmPool,
+      resourceType: "AWS::AutoScaling::WarmPool",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.ecsCodeDeployApp, resourceType: "AWS::CodeDeploy::Application", conditional: true },
+    {
+      logicalName: cfLogicalNames.codeDeployDeploymentGroup,
+      resourceType: "AWS::CodeDeploy::DeploymentGroup",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsLogGroup,
+      resourceType: "AWS::Logs::LogGroup",
+      conditional: true,
+      unresolvable: true
+    },
+    { logicalName: cfLogicalNames.efsAccessPoint, resourceType: "AWS::EFS::AccessPoint", conditional: true },
+    // From application-load-balancer (conditional - only if ALB is used)
+    {
+      logicalName: cfLogicalNames.loadBalancer,
+      resourceType: "AWS::ElasticLoadBalancingV2::LoadBalancer",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.loadBalancerSecurityGroup,
+      resourceType: "AWS::EC2::SecurityGroup",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.listener, resourceType: "AWS::ElasticLoadBalancingV2::Listener", conditional: true },
+    {
+      logicalName: cfLogicalNames.webAppFirewallAssociation,
+      resourceType: "AWS::WAFv2::WebACLAssociation",
+      conditional: true
+    },
+    // From http-api-gateway (conditional - only if HTTP API Gateway is used, alternative to ALB/NLB)
+    { logicalName: cfLogicalNames.httpApi, resourceType: "AWS::ApiGatewayV2::Api", conditional: true },
+    { logicalName: cfLogicalNames.httpApiStage, resourceType: "AWS::ApiGatewayV2::Stage", conditional: true },
+    { logicalName: cfLogicalNames.httpApiLogGroup, resourceType: "AWS::Logs::LogGroup", conditional: true },
+    {
+      logicalName: cfLogicalNames.httpApiVpcLinkSecurityGroup,
+      resourceType: "AWS::EC2::SecurityGroup",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.httpApiVpcLink, resourceType: "AWS::ApiGatewayV2::VpcLink", conditional: true },
+    { logicalName: cfLogicalNames.httpApiDomain, resourceType: "AWS::ApiGatewayV2::DomainName", conditional: true },
+    {
+      logicalName: cfLogicalNames.httpApiDomainMapping,
+      resourceType: "AWS::ApiGatewayV2::ApiMapping",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.httpApiDefaultDomain,
+      resourceType: "AWS::ApiGatewayV2::DomainName",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.httpApiDefaultDomainMapping,
+      resourceType: "AWS::ApiGatewayV2::ApiMapping",
+      conditional: true
+    },
+    // Common resources (domains, CDN - all conditional)
+    {
+      logicalName: cfLogicalNames.customResourceDefaultDomain,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.dnsRecord, resourceType: "AWS::Route53::RecordSet", conditional: true },
+    {
+      logicalName: cfLogicalNames.cloudfrontOriginAccessIdentity,
+      resourceType: "AWS::CloudFront::CloudFrontOriginAccessIdentity",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultCachePolicy,
+      resourceType: "AWS::CloudFront::CachePolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontCustomOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDefaultOriginRequestPolicy,
+      resourceType: "AWS::CloudFront::OriginRequestPolicy",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.cloudfrontDistribution,
+      resourceType: "AWS::CloudFront::Distribution",
+      conditional: true
+    }
+  ],
+  // ===== PRIVATE SERVICE =====
+  // Private service delegates to: containerWorkload + optionally loadBalancer
+  "private-service": [
+    // From multi-container-workload - core resources (always present)
+    { logicalName: cfLogicalNames.ecsCluster, resourceType: "AWS::ECS::Cluster" },
+    { logicalName: cfLogicalNames.workloadSecurityGroup, resourceType: "AWS::EC2::SecurityGroup" },
+    {
+      logicalName: cfLogicalNames.ecsService,
+      resourceType: "AWS::ECS::Service",
+      unresolvable: true
+    },
+    { logicalName: cfLogicalNames.ecsTaskRole, resourceType: "AWS::IAM::Role" },
+    { logicalName: cfLogicalNames.ecsTaskDefinition, resourceType: "AWS::ECS::TaskDefinition" },
+    // From multi-container-workload - conditional resources
+    { logicalName: cfLogicalNames.ecsExecutionRole, resourceType: "AWS::IAM::Role", conditional: true },
+    { logicalName: cfLogicalNames.ecsAutoScalingRole, resourceType: "AWS::IAM::Role", conditional: true },
+    {
+      logicalName: cfLogicalNames.autoScalingTarget,
+      resourceType: "AWS::ApplicationAutoScaling::ScalableTarget",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.autoScalingPolicy,
+      resourceType: "AWS::ApplicationAutoScaling::ScalingPolicy",
+      conditional: true,
+      unresolvable: true
+    },
+    { logicalName: cfLogicalNames.ecsEc2InstanceRole, resourceType: "AWS::IAM::Role", conditional: true },
+    {
+      logicalName: cfLogicalNames.eventBusRoleForScheduledInstanceRefresh,
+      resourceType: "AWS::IAM::Role",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.ecsEc2InstanceProfile, resourceType: "AWS::IAM::InstanceProfile", conditional: true },
+    {
+      logicalName: cfLogicalNames.ecsEc2InstanceLaunchTemplate,
+      resourceType: "AWS::EC2::LaunchTemplate",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2AutoscalingGroup,
+      resourceType: "AWS::AutoScaling::AutoScalingGroup",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2ForceDeleteAutoscalingGroupCustomResource,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2CapacityProvider,
+      resourceType: "AWS::ECS::CapacityProvider",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2CapacityProviderAssociation,
+      resourceType: "AWS::ECS::ClusterCapacityProviderAssociations",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.schedulerRuleForScheduledInstanceRefresh,
+      resourceType: "AWS::Scheduler::Schedule",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2AutoscalingGroupWarmPool,
+      resourceType: "AWS::AutoScaling::WarmPool",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.ecsCodeDeployApp, resourceType: "AWS::CodeDeploy::Application", conditional: true },
+    {
+      logicalName: cfLogicalNames.codeDeployDeploymentGroup,
+      resourceType: "AWS::CodeDeploy::DeploymentGroup",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsLogGroup,
+      resourceType: "AWS::Logs::LogGroup",
+      conditional: true,
+      unresolvable: true
+    },
+    { logicalName: cfLogicalNames.efsAccessPoint, resourceType: "AWS::EFS::AccessPoint", conditional: true },
+    // From application-load-balancer (conditional - only if ALB is configured)
+    {
+      logicalName: cfLogicalNames.loadBalancer,
+      resourceType: "AWS::ElasticLoadBalancingV2::LoadBalancer",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.loadBalancerSecurityGroup,
+      resourceType: "AWS::EC2::SecurityGroup",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.listener, resourceType: "AWS::ElasticLoadBalancingV2::Listener", conditional: true },
+    {
+      logicalName: cfLogicalNames.customResourceDefaultDomain,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.dnsRecord, resourceType: "AWS::Route53::RecordSet", conditional: true }
+  ],
+  // ===== WORKER SERVICE =====
+  // Worker service delegates to: containerWorkload only
+  "worker-service": [
+    // From multi-container-workload - core resources (always present)
+    { logicalName: cfLogicalNames.ecsCluster, resourceType: "AWS::ECS::Cluster" },
+    { logicalName: cfLogicalNames.workloadSecurityGroup, resourceType: "AWS::EC2::SecurityGroup" },
+    {
+      logicalName: cfLogicalNames.ecsService,
+      resourceType: "AWS::ECS::Service",
+      unresolvable: true
+    },
+    { logicalName: cfLogicalNames.ecsTaskRole, resourceType: "AWS::IAM::Role" },
+    { logicalName: cfLogicalNames.ecsTaskDefinition, resourceType: "AWS::ECS::TaskDefinition" },
+    // From multi-container-workload - conditional resources
+    { logicalName: cfLogicalNames.ecsExecutionRole, resourceType: "AWS::IAM::Role", conditional: true },
+    { logicalName: cfLogicalNames.ecsAutoScalingRole, resourceType: "AWS::IAM::Role", conditional: true },
+    {
+      logicalName: cfLogicalNames.autoScalingTarget,
+      resourceType: "AWS::ApplicationAutoScaling::ScalableTarget",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.autoScalingPolicy,
+      resourceType: "AWS::ApplicationAutoScaling::ScalingPolicy",
+      conditional: true,
+      unresolvable: true
+    },
+    { logicalName: cfLogicalNames.ecsEc2InstanceRole, resourceType: "AWS::IAM::Role", conditional: true },
+    {
+      logicalName: cfLogicalNames.eventBusRoleForScheduledInstanceRefresh,
+      resourceType: "AWS::IAM::Role",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.ecsEc2InstanceProfile, resourceType: "AWS::IAM::InstanceProfile", conditional: true },
+    {
+      logicalName: cfLogicalNames.ecsEc2InstanceLaunchTemplate,
+      resourceType: "AWS::EC2::LaunchTemplate",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2AutoscalingGroup,
+      resourceType: "AWS::AutoScaling::AutoScalingGroup",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2ForceDeleteAutoscalingGroupCustomResource,
+      resourceType: "AWS::CloudFormation::CustomResource",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2CapacityProvider,
+      resourceType: "AWS::ECS::CapacityProvider",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2CapacityProviderAssociation,
+      resourceType: "AWS::ECS::ClusterCapacityProviderAssociations",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.schedulerRuleForScheduledInstanceRefresh,
+      resourceType: "AWS::Scheduler::Schedule",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsEc2AutoscalingGroupWarmPool,
+      resourceType: "AWS::AutoScaling::WarmPool",
+      conditional: true
+    },
+    { logicalName: cfLogicalNames.ecsCodeDeployApp, resourceType: "AWS::CodeDeploy::Application", conditional: true },
+    {
+      logicalName: cfLogicalNames.codeDeployDeploymentGroup,
+      resourceType: "AWS::CodeDeploy::DeploymentGroup",
+      conditional: true
+    },
+    {
+      logicalName: cfLogicalNames.ecsLogGroup,
+      resourceType: "AWS::Logs::LogGroup",
+      conditional: true,
+      unresolvable: true
+    },
+    { logicalName: cfLogicalNames.efsAccessPoint, resourceType: "AWS::EFS::AccessPoint", conditional: true },
+    {
+      logicalName: cfLogicalNames.atlasMongoUserAssociatedWithRole,
+      resourceType: "MongoDB::StpAtlasV1::DatabaseUser",
+      conditional: true
+    }
+  ],
+  // ===== OTHER RESOURCES =====
+  "custom-resource-instance": [],
+  "custom-resource-definition": [],
+  "deployment-script": [],
+  "aws-cdk-construct": []
+};
+
+// src/api/npm/ts/config.ts
+var getParamReferenceSymbol = Symbol.for("stacktape:getParamReference");
+var getTypeSymbol = Symbol.for("stacktape:getType");
+var getPropertiesSymbol = Symbol.for("stacktape:getProperties");
+var getOverridesSymbol = Symbol.for("stacktape:getOverrides");
+var ResourceParamReference = class {
+  static {
+    __name(this, "ResourceParamReference");
+  }
+  constructor(resourceName, param) {
+    this.__resourceName = resourceName;
+    this.__param = param;
+  }
+  toString() {
+    return `$ResourceParam('${this.__resourceName}', '${this.__param}')`;
+  }
+  toJSON() {
+    return this.toString();
+  }
+  // Allow the reference to be used directly in template strings
+  valueOf() {
+    return this.toString();
+  }
+};
+var BaseTypeProperties = class {
+  static {
+    __name(this, "BaseTypeProperties");
+  }
+  constructor(type, properties) {
+    this.type = type;
+    this.properties = properties;
+  }
+};
+var BaseResource = class {
+  static {
+    __name(this, "BaseResource");
+  }
+  constructor(name, type, properties, overrides) {
+    this._resourceName = name;
+    this._type = type;
+    let finalProperties = properties;
+    let finalOverrides = overrides;
+    if (properties && typeof properties === "object" && "overrides" in properties) {
+      finalProperties = { ...properties };
+      const propertiesOverrides = finalProperties.overrides;
+      delete finalProperties.overrides;
+      if (propertiesOverrides && typeof propertiesOverrides === "object") {
+        finalOverrides = transformOverridesToLogicalNames(name, type, propertiesOverrides);
+      }
+    }
+    this._properties = finalProperties;
+    this._overrides = finalOverrides;
+  }
+  // Public getter for resource name (used for referencing resources)
+  get resourceName() {
+    return this._resourceName;
+  }
+  // Private methods using symbols - not accessible from outside or in autocomplete
+  [getParamReferenceSymbol](paramName) {
+    return new ResourceParamReference(this._resourceName, paramName);
+  }
+  [getTypeSymbol]() {
+    return this._type;
+  }
+  [getPropertiesSymbol]() {
+    return this._properties;
+  }
+  [getOverridesSymbol]() {
+    return this._overrides;
+  }
+};
+function transformOverridesToLogicalNames(resourceName, resourceType, overrides) {
+  const childResources = CHILD_RESOURCES[resourceType] || [];
+  const propertyNameMap = /* @__PURE__ */ new Map();
+  for (const childResource of childResources) {
+    if (childResource.logicalName && childResource.logicalName.name) {
+      propertyNameMap.set(childResource.logicalName.name, childResource);
+    }
+  }
+  const transformedOverrides = {};
+  const errorMessage = `Override of property {propertyName} of resource ${resourceName} is not supported.
+
+Remove the override, run 'stacktape compile:template' command, and find the logical name of the resource you want to override manually. Then add it to the overrides object.`;
+  for (const propertyName in overrides) {
+    const childResource = propertyNameMap.get(propertyName);
+    if (childResource?.unresolvable) {
+      throw new Error(errorMessage.replace("{propertyName}", propertyName));
+    }
+    if (childResource) {
+      const logicalNameFn = childResource.logicalName;
+      let logicalName;
+      try {
+        logicalName = logicalNameFn(resourceName);
+      } catch {
+        try {
+          logicalName = logicalNameFn();
+        } catch {
+          logicalName = propertyName;
+        }
+      }
+      if (logicalName.includes("undefined")) {
+        throw new Error(errorMessage.replace("{propertyName}", propertyName));
+      }
+      transformedOverrides[logicalName] = overrides[propertyName];
+    } else {
+      transformedOverrides[propertyName] = overrides[propertyName];
+    }
+  }
+  return transformedOverrides;
+}
+__name(transformOverridesToLogicalNames, "transformOverridesToLogicalNames");
+var defineConfig = /* @__PURE__ */ __name((configFn) => {
+  return (params) => {
+    const config = configFn(params);
+    return transformConfigWithResources(config);
+  };
+}, "defineConfig");
+var transformConfigWithResources = /* @__PURE__ */ __name((config) => {
+  if (!config || typeof config !== "object") {
+    return config;
+  }
+  const result = {};
+  for (const key in config) {
+    if (key === "resources") {
+      result[key] = transformResourceDefinitions(config[key]);
+    } else if (key === "scripts") {
+      result[key] = transformScriptDefinitions(config[key]);
+    } else {
+      result[key] = transformValue(config[key]);
+    }
+  }
+  return result;
+}, "transformConfigWithResources");
+var transformEnvironment = /* @__PURE__ */ __name((env) => {
+  if (!env || typeof env !== "object" || Array.isArray(env)) {
+    return env;
+  }
+  return Object.entries(env).map(([name, value]) => ({
+    name,
+    value: transformValue(value)
+  }));
+}, "transformEnvironment");
+var transformResourceDefinitions = /* @__PURE__ */ __name((resources) => {
+  if (!resources || typeof resources !== "object") {
+    return resources;
+  }
+  const result = {};
+  for (const key in resources) {
+    const resource = resources[key];
+    if (resource instanceof BaseResource) {
+      const type = resource[getTypeSymbol]();
+      const properties = resource[getPropertiesSymbol]();
+      const overrides = resource[getOverridesSymbol]();
+      result[key] = {
+        type,
+        properties: transformValue(properties),
+        ...overrides !== void 0 && { overrides: transformValue(overrides) }
+      };
+    } else {
+      result[key] = transformValue(resource);
+    }
+  }
+  return result;
+}, "transformResourceDefinitions");
+var transformScriptDefinitions = /* @__PURE__ */ __name((scripts) => {
+  if (!scripts || typeof scripts !== "object") {
+    return scripts;
+  }
+  const result = {};
+  for (const key in scripts) {
+    const script = scripts[key];
+    if (script instanceof BaseTypeProperties) {
+      result[key] = {
+        type: script.type,
+        properties: transformValue(script.properties)
+      };
+    } else {
+      result[key] = transformValue(script);
+    }
+  }
+  return result;
+}, "transformScriptDefinitions");
+var transformValue = /* @__PURE__ */ __name((value) => {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (value instanceof ResourceParamReference) {
+    return value.toString();
+  }
+  if (value instanceof BaseResource) {
+    return value.resourceName;
+  }
+  if (value instanceof BaseTypeProperties) {
+    return {
+      type: value.type,
+      properties: transformValue(value.properties)
+    };
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      if (item instanceof BaseResource) {
+        return item.resourceName;
+      }
+      return transformValue(item);
+    });
+  }
+  if (typeof value === "object") {
+    const result = {};
+    for (const key in value) {
+      if (key === "environment") {
+        result[key] = transformEnvironment(value[key]);
+      } else {
+        result[key] = transformValue(value[key]);
+      }
+    }
+    return result;
+  }
+  return value;
+}, "transformValue");
+
+// src/api/npm/ts/directives.ts
+var $ResourceParam = /* @__PURE__ */ __name((resourceName, property) => {
+  return `$ResourceParam('${resourceName}','${property}')`;
+}, "$ResourceParam");
+var $CfResourceParam = /* @__PURE__ */ __name((cloudformationResourceLogicalId, property) => {
+  return `$CfResourceParam('${cloudformationResourceLogicalId}','${property}')`;
+}, "$CfResourceParam");
+var $Secret = /* @__PURE__ */ __name((secretName) => {
+  return `$Secret('${secretName}')`;
+}, "$Secret");
+var $CfFormat = /* @__PURE__ */ __name((interpolatedString, ...values) => {
+  return `$CfFormat('${interpolatedString}', '${values.join(",")}')`;
+}, "$CfFormat");
+var $CfStackOutput = /* @__PURE__ */ __name((stackName, outputName) => {
+  return `$CfStackOutput('${stackName}','${outputName}')`;
+}, "$CfStackOutput");
+var $GitInfo = /* @__PURE__ */ __name(() => {
+  return "$GitInfo()";
+}, "$GitInfo");
+
+// src/api/npm/ts/global-aws-services.ts
+var AWS_SES = "aws:ses";
+
+// src/api/npm/ts/resource-metadata.ts
+var REFERENCEABLE_PARAMS = {
+  "relational-database": [
+    { name: "connectionString", description: "Connection string for the database" },
+    { name: "jdbcConnectionString", description: "JDBC connection string" },
+    { name: "host", description: "Database host" },
+    { name: "port", description: "Database port" },
+    { name: "dbName", description: "Database name" },
+    { name: "readerHost", description: "Reader endpoint host" },
+    { name: "readerConnectionString", description: "Reader connection string" },
+    { name: "readerJdbcConnectionString", description: "Reader JDBC connection string" }
+  ],
+  "web-service": [
+    { name: "domain", description: "Web service domain" },
+    { name: "url", description: "Web service URL" },
+    { name: "customDomains", description: "Custom domains" },
+    { name: "customDomainUrls", description: "Custom domain URLs" }
+  ],
+  "private-service": [{ name: "address", description: "Private service address" }],
+  bucket: [
+    { name: "name", description: "Bucket name" },
+    { name: "arn", description: "Bucket ARN" }
+  ],
+  "dynamo-db-table": [
+    { name: "name", description: "Table name" },
+    { name: "arn", description: "Table ARN" },
+    { name: "streamArn", description: "Stream ARN" }
+  ],
+  function: [
+    { name: "arn", description: "Function ARN" },
+    { name: "logGroupArn", description: "Log group ARN" }
+  ],
+  "batch-job": [
+    { name: "jobDefinitionArn", description: "Job definition ARN" },
+    { name: "stateMachineArn", description: "State machine ARN" },
+    { name: "logGroupArn", description: "Log group ARN" }
+  ],
+  "event-bus": [
+    { name: "arn", description: "Event bus ARN" },
+    { name: "archiveArn", description: "Archive ARN" }
+  ],
+  "http-api-gateway": [
+    { name: "domain", description: "API Gateway domain" },
+    { name: "url", description: "API Gateway URL" },
+    { name: "customDomains", description: "Custom domains" },
+    { name: "customDomainUrls", description: "Custom domain URLs" },
+    { name: "customDomainUrl", description: "First custom domain URL" }
+  ],
+  "mongo-db-atlas-cluster": [{ name: "connectionString", description: "MongoDB connection string" }],
+  "redis-cluster": [
+    { name: "host", description: "Redis host" },
+    { name: "readerHost", description: "Redis reader host" },
+    { name: "port", description: "Redis port" },
+    { name: "sharding", description: "Sharding status" }
+  ],
+  "state-machine": [
+    { name: "arn", description: "State machine ARN" },
+    { name: "name", description: "State machine name" }
+  ],
+  "user-auth-pool": [
+    { name: "id", description: "User pool ID" },
+    { name: "clientId", description: "Client ID" },
+    { name: "domain", description: "User pool domain" }
+  ],
+  "upstash-redis": [
+    { name: "host", description: "Upstash Redis host" },
+    { name: "port", description: "Upstash Redis port" },
+    { name: "password", description: "Password" },
+    { name: "restToken", description: "REST token" },
+    { name: "readOnlyRestToken", description: "Read-only REST token" },
+    { name: "restUrl", description: "REST URL" },
+    { name: "redisUrl", description: "Redis URL" }
+  ],
+  "application-load-balancer": [
+    { name: "domain", description: "Load balancer domain" },
+    { name: "customDomains", description: "Custom domains" }
+  ],
+  "network-load-balancer": [
+    { name: "domain", description: "Load balancer domain" },
+    { name: "customDomains", description: "Custom domains" }
+  ],
+  "hosting-bucket": [
+    { name: "name", description: "Bucket name" },
+    { name: "arn", description: "Bucket ARN" }
+  ],
+  "web-app-firewall": [
+    { name: "arn", description: "Firewall ARN" },
+    { name: "scope", description: "Firewall scope" }
+  ],
+  "open-search-domain": [
+    { name: "domainEndpoint", description: "OpenSearch domain endpoint" },
+    { name: "arn", description: "Domain ARN" }
+  ],
+  "efs-filesystem": [
+    { name: "arn", description: "EFS ARN" },
+    { name: "id", description: "EFS ID" }
+  ],
+  "nextjs-web": [{ name: "url", description: "Website URL" }]
+};
+
+// src/api/npm/ts/resources.ts
+var getParamReferenceSymbol2 = Symbol.for("stacktape:getParamReference");
+function createResourceClass(className, resourceType) {
+  const ResourceClass = class extends BaseResource {
+    static {
+      __name(this, "ResourceClass");
+    }
+    constructor(name, properties, overrides) {
+      super(name, resourceType, properties, overrides);
+    }
+  };
+  Object.defineProperty(ResourceClass, "name", { value: className });
+  const referenceableParams = REFERENCEABLE_PARAMS[resourceType] || [];
+  for (const param of referenceableParams) {
+    Object.defineProperty(ResourceClass.prototype, param.name, {
+      get() {
+        return this[getParamReferenceSymbol2](param.name);
+      },
+      enumerable: false,
+      configurable: true
+    });
+  }
+  return ResourceClass;
+}
+__name(createResourceClass, "createResourceClass");
+var RelationalDatabase = createResourceClass("RelationalDatabase", "relational-database");
+var WebService = createResourceClass("WebService", "web-service");
+var PrivateService = createResourceClass("PrivateService", "private-service");
+var WorkerService = createResourceClass("WorkerService", "worker-service");
+var ContainerWorkload = createResourceClass("ContainerWorkload", "multi-container-workload");
+var LambdaFunction = createResourceClass("LambdaFunction", "function");
+var BatchJob = createResourceClass("BatchJob", "batch-job");
+var Bucket = createResourceClass("Bucket", "bucket");
+var HostingBucket = createResourceClass("HostingBucket", "hosting-bucket");
+var DynamoDbTable = createResourceClass("DynamoDbTable", "dynamo-db-table");
+var EventBus = createResourceClass("EventBus", "event-bus");
+var HttpApiGateway = createResourceClass("HttpApiGateway", "http-api-gateway");
+var ApplicationLoadBalancer = createResourceClass("ApplicationLoadBalancer", "application-load-balancer");
+var NetworkLoadBalancer = createResourceClass("NetworkLoadBalancer", "network-load-balancer");
+var RedisCluster = createResourceClass("RedisCluster", "redis-cluster");
+var MongoDbAtlasCluster = createResourceClass("MongoDbAtlasCluster", "mongo-db-atlas-cluster");
+var StateMachine = createResourceClass("StateMachine", "state-machine");
+var UserAuthPool = createResourceClass("UserAuthPool", "user-auth-pool");
+var UpstashRedis = createResourceClass("UpstashRedis", "upstash-redis");
+var SqsQueue = createResourceClass("SqsQueue", "sqs-queue");
+var SnsTopic = createResourceClass("SnsTopic", "sns-topic");
+var WebAppFirewall = createResourceClass("WebAppFirewall", "web-app-firewall");
+var OpenSearchDomain = createResourceClass("OpenSearchDomain", "open-search-domain");
+var EfsFilesystem = createResourceClass("EfsFilesystem", "efs-filesystem");
+var NextjsWeb = createResourceClass("NextjsWeb", "nextjs-web");
+var Bastion = createResourceClass("Bastion", "bastion");
+
+// src/api/npm/ts/type-properties.ts
+function createTypePropertiesClass(className, typeValue) {
+  const TypePropertiesClass = class extends BaseTypeProperties {
+    static {
+      __name(this, "TypePropertiesClass");
+    }
+    constructor(properties) {
+      super(typeValue, properties);
+    }
+  };
+  Object.defineProperty(TypePropertiesClass, "name", { value: className });
+  return TypePropertiesClass;
+}
+__name(createTypePropertiesClass, "createTypePropertiesClass");
+var RdsEnginePostgres = createTypePropertiesClass("RdsEnginePostgres", "postgres");
+var RdsEngineMariadb = createTypePropertiesClass("RdsEngineMariadb", "mariadb");
+var RdsEngineMysql = createTypePropertiesClass("RdsEngineMysql", "mysql");
+var RdsEngineOracleEE = createTypePropertiesClass("RdsEngineOracleEE", "oracle-ee");
+var RdsEngineOracleSE2 = createTypePropertiesClass("RdsEngineOracleSE2", "oracle-se2");
+var RdsEngineSqlServerEE = createTypePropertiesClass("RdsEngineSqlServerEE", "sqlserver-ee");
+var RdsEngineSqlServerEX = createTypePropertiesClass("RdsEngineSqlServerEX", "sqlserver-ex");
+var RdsEngineSqlServerSE = createTypePropertiesClass("RdsEngineSqlServerSE", "sqlserver-se");
+var RdsEngineSqlServerWeb = createTypePropertiesClass("RdsEngineSqlServerWeb", "sqlserver-web");
+var AuroraEnginePostgresql = createTypePropertiesClass("AuroraEnginePostgresql", "aurora-postgresql");
+var AuroraEngineMysql = createTypePropertiesClass("AuroraEngineMysql", "aurora-mysql");
+var AuroraServerlessEnginePostgresql = createTypePropertiesClass(
+  "AuroraServerlessEnginePostgresql",
+  "aurora-postgresql-serverless"
+);
+var AuroraServerlessEngineMysql = createTypePropertiesClass(
+  "AuroraServerlessEngineMysql",
+  "aurora-mysql-serverless"
+);
+var AuroraServerlessV2EnginePostgresql = createTypePropertiesClass(
+  "AuroraServerlessV2EnginePostgresql",
+  "aurora-postgresql-serverless-v2"
+);
+var AuroraServerlessV2EngineMysql = createTypePropertiesClass(
+  "AuroraServerlessV2EngineMysql",
+  "aurora-mysql-serverless-v2"
+);
+var StacktapeLambdaBuildpackPackaging = createTypePropertiesClass(
+  "StacktapeLambdaBuildpackPackaging",
+  "stacktape-lambda-buildpack"
+);
+var CustomArtifactLambdaPackaging = createTypePropertiesClass(
+  "CustomArtifactLambdaPackaging",
+  "custom-artifact"
+);
+var PrebuiltImagePackaging = createTypePropertiesClass("PrebuiltImagePackaging", "prebuilt-image");
+var CustomDockerfilePackaging = createTypePropertiesClass("CustomDockerfilePackaging", "custom-dockerfile");
+var ExternalBuildpackPackaging = createTypePropertiesClass("ExternalBuildpackPackaging", "external-buildpack");
+var NixpacksPackaging = createTypePropertiesClass("NixpacksPackaging", "nixpacks");
+var StacktapeImageBuildpackPackaging = createTypePropertiesClass(
+  "StacktapeImageBuildpackPackaging",
+  "stacktape-image-buildpack"
+);
+var HttpApiIntegration = createTypePropertiesClass("HttpApiIntegration", "http-api-gateway");
+var S3Integration = createTypePropertiesClass("S3Integration", "s3");
+var ScheduleIntegration = createTypePropertiesClass("ScheduleIntegration", "schedule");
+var SnsIntegration = createTypePropertiesClass("SnsIntegration", "sns");
+var SqsIntegration = createTypePropertiesClass("SqsIntegration", "sqs");
+var KinesisIntegration = createTypePropertiesClass("KinesisIntegration", "kinesis");
+var DynamoDbIntegration = createTypePropertiesClass("DynamoDbIntegration", "dynamodb");
+var CloudwatchLogIntegration = createTypePropertiesClass("CloudwatchLogIntegration", "cloudwatch-logs");
+var ApplicationLoadBalancerIntegration = createTypePropertiesClass(
+  "ApplicationLoadBalancerIntegration",
+  "application-load-balancer"
+);
+var EventBusIntegration = createTypePropertiesClass("EventBusIntegration", "event-bus");
+var KafkaTopicIntegration = createTypePropertiesClass("KafkaTopicIntegration", "kafka-topic");
+var AlarmIntegration = createTypePropertiesClass("AlarmIntegration", "alarm");
+var CdnLoadBalancerRoute = createTypePropertiesClass("CdnLoadBalancerRoute", "application-load-balancer");
+var CdnHttpApiGatewayRoute = createTypePropertiesClass("CdnHttpApiGatewayRoute", "http-api-gateway");
+var CdnLambdaFunctionRoute = createTypePropertiesClass("CdnLambdaFunctionRoute", "function");
+var CdnCustomDomainRoute = createTypePropertiesClass("CdnCustomDomainRoute", "custom-origin");
+var CdnBucketRoute = createTypePropertiesClass("CdnBucketRoute", "bucket");
+var ManagedRuleGroup = createTypePropertiesClass("ManagedRuleGroup", "managed-rule-group");
+var CustomRuleGroup = createTypePropertiesClass("CustomRuleGroup", "custom-rule-group");
+var RateBasedRule = createTypePropertiesClass("RateBasedRule", "rate-based-rule");
+var SqsQueueEventBusIntegration = createTypePropertiesClass("SqsQueueEventBusIntegration", "event-bus");
+var ContainerWorkloadHttpApiIntegration = createTypePropertiesClass(
+  "ContainerWorkloadHttpApiIntegration",
+  "http-api-gateway"
+);
+var ContainerWorkloadInternalIntegration = createTypePropertiesClass(
+  "ContainerWorkloadInternalIntegration",
+  "internal"
+);
+var ContainerWorkloadServiceConnectIntegration = createTypePropertiesClass(
+  "ContainerWorkloadServiceConnectIntegration",
+  "service-connect"
+);
+var LocalScriptWithCommand = createTypePropertiesClass("LocalScriptWithCommand", "local-script");
+var LocalScriptWithCommands = createTypePropertiesClass("LocalScriptWithCommands", "local-script");
+var LocalScriptWithFileScript = createTypePropertiesClass("LocalScriptWithFileScript", "local-script");
+var LocalScriptWithFileScripts = createTypePropertiesClass("LocalScriptWithFileScripts", "local-script");
+var BastionScriptWithCommand = createTypePropertiesClass("BastionScriptWithCommand", "bastion-script");
+var BastionScriptWithCommands = createTypePropertiesClass("BastionScriptWithCommands", "bastion-script");
+var LocalScriptWithBastionTunnelingCommand = createTypePropertiesClass(
+  "LocalScriptWithBastionTunnelingCommand",
+  "local-script-with-bastion-tunneling"
+);
+var LocalScriptWithBastionTunnelingCommands = createTypePropertiesClass(
+  "LocalScriptWithBastionTunnelingCommands",
+  "local-script-with-bastion-tunneling"
+);
+var LocalScriptWithBastionTunnelingFileScript = createTypePropertiesClass(
+  "LocalScriptWithBastionTunnelingFileScript",
+  "local-script-with-bastion-tunneling"
+);
+var LocalScriptWithBastionTunnelingFileScripts = createTypePropertiesClass(
+  "LocalScriptWithBastionTunnelingFileScripts",
+  "local-script-with-bastion-tunneling"
+);
+var HttpEndpointLogForwarding = createTypePropertiesClass("HttpEndpointLogForwarding", "http-endpoint");
+var HighlightLogForwarding = createTypePropertiesClass("HighlightLogForwarding", "highlight");
+var DatadogLogForwarding = createTypePropertiesClass("DatadogLogForwarding", "datadog");
+var ExpirationLifecycleRule = createTypePropertiesClass("ExpirationLifecycleRule", "expiration");
+var NonCurrentVersionExpirationLifecycleRule = createTypePropertiesClass(
+  "NonCurrentVersionExpirationLifecycleRule",
+  "non-current-version-expiration"
+);
+var ContainerEfsMount = createTypePropertiesClass("ContainerEfsMount", "efs");
+var LambdaEfsMount = createTypePropertiesClass("LambdaEfsMount", "efs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $CfFormat,
+  $CfResourceParam,
+  $CfStackOutput,
+  $GitInfo,
+  $ResourceParam,
+  $Secret,
+  AWS_SES,
+  AlarmIntegration,
+  ApplicationLoadBalancer,
+  ApplicationLoadBalancerIntegration,
+  AuroraEngineMysql,
+  AuroraEnginePostgresql,
+  AuroraServerlessEngineMysql,
+  AuroraServerlessEnginePostgresql,
+  AuroraServerlessV2EngineMysql,
+  AuroraServerlessV2EnginePostgresql,
+  BaseResource,
+  BaseTypeProperties,
+  Bastion,
+  BastionScriptWithCommand,
+  BastionScriptWithCommands,
+  BatchJob,
+  Bucket,
+  CdnBucketRoute,
+  CdnCustomDomainRoute,
+  CdnHttpApiGatewayRoute,
+  CdnLambdaFunctionRoute,
+  CdnLoadBalancerRoute,
+  CloudwatchLogIntegration,
+  ContainerEfsMount,
+  ContainerWorkload,
+  ContainerWorkloadHttpApiIntegration,
+  ContainerWorkloadInternalIntegration,
+  ContainerWorkloadServiceConnectIntegration,
+  CustomArtifactLambdaPackaging,
+  CustomDockerfilePackaging,
+  CustomRuleGroup,
+  DatadogLogForwarding,
+  DynamoDbIntegration,
+  DynamoDbTable,
+  EfsFilesystem,
+  EventBus,
+  EventBusIntegration,
+  ExpirationLifecycleRule,
+  ExternalBuildpackPackaging,
+  HighlightLogForwarding,
+  HostingBucket,
+  HttpApiGateway,
+  HttpApiIntegration,
+  HttpEndpointLogForwarding,
+  KafkaTopicIntegration,
+  KinesisIntegration,
+  LambdaEfsMount,
+  LambdaFunction,
+  LocalScriptWithBastionTunnelingCommand,
+  LocalScriptWithBastionTunnelingCommands,
+  LocalScriptWithBastionTunnelingFileScript,
+  LocalScriptWithBastionTunnelingFileScripts,
+  LocalScriptWithCommand,
+  LocalScriptWithCommands,
+  LocalScriptWithFileScript,
+  LocalScriptWithFileScripts,
+  ManagedRuleGroup,
+  MongoDbAtlasCluster,
+  NetworkLoadBalancer,
+  NextjsWeb,
+  NixpacksPackaging,
+  NonCurrentVersionExpirationLifecycleRule,
+  OpenSearchDomain,
+  PrebuiltImagePackaging,
+  PrivateService,
+  RateBasedRule,
+  RdsEngineMariadb,
+  RdsEngineMysql,
+  RdsEngineOracleEE,
+  RdsEngineOracleSE2,
+  RdsEnginePostgres,
+  RdsEngineSqlServerEE,
+  RdsEngineSqlServerEX,
+  RdsEngineSqlServerSE,
+  RdsEngineSqlServerWeb,
+  RedisCluster,
+  RelationalDatabase,
+  ResourceParamReference,
+  S3Integration,
+  ScheduleIntegration,
+  SnsIntegration,
+  SnsTopic,
+  SqsIntegration,
+  SqsQueue,
+  SqsQueueEventBusIntegration,
+  StacktapeImageBuildpackPackaging,
+  StacktapeLambdaBuildpackPackaging,
+  StateMachine,
+  UpstashRedis,
+  UserAuthPool,
+  WebAppFirewall,
+  WebService,
+  WorkerService,
+  defineConfig,
+  transformConfigWithResources,
+  transformValue
+});
+//# sourceMappingURL=index.js.map