terruvim-core-test 0.0.1

package/dist/src/factories/smtpUserFactory.js

@@ -0,0 +1,108 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmtpUserFactory = void 0;
+const aws = __importStar(require("@pulumi/aws"));
+const resourceFactory_1 = require("./resourceFactory");
+const createIamUserWithAccessKey_1 = require("./createIamUserWithAccessKey");
+class SmtpUserFactory extends resourceFactory_1.ResourceFactory {
+    accessKey;
+    currentConfig;
+    validateConfig(config) {
+        if (!config.configuration?.userName) {
+            throw new Error("userName is required");
+        }
+        if (!config.configuration?.sesRegion) {
+            throw new Error("sesRegion is required");
+        }
+        if (!config.configuration?.permissions?.sesActions?.length) {
+            throw new Error("permissions.sesActions is required");
+        }
+        if (!config.configuration?.permissions?.sesResources?.length) {
+            throw new Error("permissions.sesResources is required");
+        }
+    }
+    async createResource(config) {
+        this.validateConfig(config);
+        this.currentConfig = config;
+        const cfg = config.configuration;
+        const { user, accessKey } = (0, createIamUserWithAccessKey_1.createIamUserWithAccessKey)({
+            name: cfg.userName
+        });
+        this.accessKey = accessKey;
+        const policy = new aws.iam.UserPolicy(`${cfg.userName}-ses-policy`, {
+            name: `${cfg.userName}-ses-policy`,
+            user: user.name,
+            policy: JSON.stringify({
+                Version: "2012-10-17",
+                Statement: [{
+                        Effect: "Allow",
+                        Action: cfg.permissions.sesActions,
+                        Resource: cfg.permissions.sesResources
+                    }]
+            })
+        });
+        return user;
+    }
+    generateSmtpPassword(secretAccessKey, region) {
+        return secretAccessKey.apply(secret => {
+            const crypto = require("crypto");
+            const version = Buffer.from([0x04]);
+            const message = Buffer.from("SendRawEmail", "utf8");
+            const hmac = crypto.createHmac("sha256", secret);
+            hmac.update(message);
+            const signature = hmac.digest();
+            const smtpPassword = Buffer.concat([version, signature]).toString("base64");
+            return smtpPassword;
+        });
+    }
+    getOutputs(resource) {
+        if (!this.accessKey) {
+            throw new Error("Access key not created. Set createAccessKey to true.");
+        }
+        if (!this.currentConfig) {
+            throw new Error("Configuration not available.");
+        }
+        return {
+            userArn: resource.arn,
+            userName: resource.name,
+            accessKeyId: this.accessKey.id,
+            secretAccessKey: this.accessKey.secret,
+            smtpPassword: this.generateSmtpPassword(this.accessKey.secret, this.currentConfig.configuration.sesRegion),
+            smtpUsername: this.accessKey.id
+        };
+    }
+}
+exports.SmtpUserFactory = SmtpUserFactory;

package/dist/src/factories/snsFactory.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnsFactory = void 0;
+const aws = __importStar(require("@pulumi/aws"));
+const resourceFactory_1 = require("./resourceFactory");
+const validateSnsConfig_1 = require("./validateSnsConfig");
+const createAwsSnsTopic_1 = require("./createAwsSnsTopic");
+class SnsFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config) {
+        (0, validateSnsConfig_1.validateSnsConfig)(config);
+        const topic = (0, createAwsSnsTopic_1.createAwsSnsTopic)(config.configuration.name, {
+            name: config.configuration.name,
+            displayName: config.configuration.displayName,
+            fifoTopic: config.configuration.fifoTopic,
+            contentBasedDeduplication: config.configuration.contentBasedDeduplication,
+            kmsMasterKeyId: config.configuration.kmsMasterKeyId,
+            deliveryPolicy: config.configuration.deliveryPolicy ? JSON.stringify(config.configuration.deliveryPolicy) : undefined,
+            policy: config.configuration.policy ? JSON.stringify(config.configuration.policy) : undefined,
+            tags: config.configuration.tags,
+            signatureVersion: config.configuration.signatureVersion,
+            applicationSuccessFeedbackRoleArn: config.configuration.applicationSuccessFeedbackRoleArn,
+            applicationSuccessFeedbackSampleRate: config.configuration.applicationSuccessFeedbackSampleRate,
+            applicationFailureFeedbackRoleArn: config.configuration.applicationFailureFeedbackRoleArn,
+            httpSuccessFeedbackRoleArn: config.configuration.httpSuccessFeedbackRoleArn,
+            httpSuccessFeedbackSampleRate: config.configuration.httpSuccessFeedbackSampleRate,
+            httpFailureFeedbackRoleArn: config.configuration.httpFailureFeedbackRoleArn,
+            lambdaSuccessFeedbackRoleArn: config.configuration.lambdaSuccessFeedbackRoleArn,
+            lambdaSuccessFeedbackSampleRate: config.configuration.lambdaSuccessFeedbackSampleRate,
+            lambdaFailureFeedbackRoleArn: config.configuration.lambdaFailureFeedbackRoleArn,
+            sqsSuccessFeedbackRoleArn: config.configuration.sqsSuccessFeedbackRoleArn,
+            sqsSuccessFeedbackSampleRate: config.configuration.sqsSuccessFeedbackSampleRate,
+            sqsFailureFeedbackRoleArn: config.configuration.sqsFailureFeedbackRoleArn,
+            tracingConfig: config.configuration.tracingConfig,
+        });
+        if (config.configuration.email) {
+            new aws.sns.TopicSubscription(`${config.configuration.name}-email-subscription`, {
+                topic: topic.arn,
+                protocol: "email",
+                endpoint: config.configuration.email,
+            });
+        }
+        return topic;
+    }
+    getOutputs(resource) {
+        return {
+            arn: resource.arn,
+            name: resource.name,
+        };
+    }
+    validateConfig(config) {
+        (0, validateSnsConfig_1.validateSnsConfig)(config);
+    }
+}
+exports.SnsFactory = SnsFactory;

package/dist/src/factories/sqsFactory.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqsFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const validateSqsConfig_1 = require("./validateSqsConfig");
+const createAwsSqsQueue_1 = require("./createAwsSqsQueue");
+class SqsFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config) {
+        (0, validateSqsConfig_1.validateSqsConfig)(config);
+        return (0, createAwsSqsQueue_1.createAwsSqsQueue)(config.configuration.name, {
+            name: config.configuration.name,
+            fifoQueue: config.configuration.fifoQueue,
+            contentBasedDeduplication: config.configuration.contentBasedDeduplication,
+            delaySeconds: config.configuration.delaySeconds,
+            maxMessageSize: config.configuration.maximumMessageSize,
+            messageRetentionSeconds: config.configuration.messageRetentionSeconds,
+            receiveWaitTimeSeconds: config.configuration.receiveWaitTimeSeconds,
+            visibilityTimeoutSeconds: config.configuration.visibilityTimeoutSeconds,
+            kmsMasterKeyId: config.configuration.kmsMasterKeyId,
+            kmsDataKeyReusePeriodSeconds: config.configuration.kmsDataKeyReusePeriodSeconds,
+            redrivePolicy: config.configuration.redrivePolicy,
+            policy: config.configuration.policy,
+            tags: config.configuration.tags,
+            sqsManagedSseEnabled: config.configuration.sqsManagedSseEnabled,
+            deduplicationScope: config.configuration.deduplicationScope,
+            fifoThroughputLimit: config.configuration.fifoThroughputLimit,
+            redriveAllowPolicy: config.configuration.redriveAllowPolicy,
+        });
+    }
+    getOutputs(resource) {
+        return {
+            arn: resource.arn,
+            name: resource.name,
+            url: resource.url,
+        };
+    }
+    validateConfig(config) {
+        (0, validateSqsConfig_1.validateSqsConfig)(config);
+    }
+}
+exports.SqsFactory = SqsFactory;

package/dist/src/factories/ssmParameterFactory.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSMParameterFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const validateSsmParameterFactoryConfig_1 = require("./validateSsmParameterFactoryConfig");
+const createAwsSsmParameters_1 = require("./createAwsSsmParameters");
+class SSMParameterFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config) {
+        function getProp(key) {
+            if (!config)
+                return undefined;
+            if (key in config)
+                return config[key];
+            if (config.configuration && key in config.configuration)
+                return config.configuration[key];
+            return undefined;
+        }
+        const configParams = getProp("parameters");
+        if (!configParams) {
+            const singleParamConfig = {
+                id: getProp("id"),
+                configuration: {
+                    parameters: [{
+                            name: getProp("name"),
+                            type: getProp("type"),
+                            value: getProp("value"),
+                            description: getProp("description"),
+                            keyId: getProp("keyId"),
+                            overwrite: getProp("overwrite"),
+                            tags: getProp("tags")
+                        }],
+                    tags: getProp("tags")
+                }
+            };
+            (0, validateSsmParameterFactoryConfig_1.validateSsmParameterFactoryConfig)(singleParamConfig);
+            return await (0, createAwsSsmParameters_1.createAwsSsmParameters)(singleParamConfig);
+        }
+        else {
+            (0, validateSsmParameterFactoryConfig_1.validateSsmParameterFactoryConfig)(config);
+            return await (0, createAwsSsmParameters_1.createAwsSsmParameters)(config);
+        }
+    }
+    getOutputs(resource) {
+        return resource;
+    }
+    validateConfig(config) {
+        function getProp(key) {
+            if (!config)
+                return undefined;
+            if (key in config)
+                return config[key];
+            if (config.configuration && key in config.configuration)
+                return config.configuration[key];
+            return undefined;
+        }
+        const configParams = getProp("parameters");
+        if (!configParams) {
+            if (!getProp("id") || !getProp("name") || !getProp("type") || !getProp("value")) {
+                throw new Error("SSM Parameter must have id, name, type, and value");
+            }
+        }
+        else {
+            (0, validateSsmParameterFactoryConfig_1.validateSsmParameterFactoryConfig)(config);
+        }
+    }
+}
+exports.SSMParameterFactory = SSMParameterFactory;

package/dist/src/factories/ssoFactory.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSOFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const createAwsSsoAccountAssignment_1 = require("./createAwsSsoAccountAssignment");
+class SSOFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config) {
+        if (config.hooks?.beforeCreateResources)
+            await config.hooks.beforeCreateResources(config);
+        const resources = {};
+        if (config.configuration.instances) {
+            resources.instances = config.configuration.instances.map(inst => ({
+                ...inst,
+                kind: "SsoInstance"
+            }));
+        }
+        if (config.configuration.assignments) {
+            resources.assignments = config.configuration.assignments.map(a => (0, createAwsSsoAccountAssignment_1.createAwsSsoAccountAssignment)(a));
+        }
+        if (config.hooks?.afterCreateResources)
+            await config.hooks.afterCreateResources(resources, config);
+        return resources;
+    }
+    getOutputs(resource) {
+        return resource;
+    }
+    validateConfig(config) {
+        if (!config.id)
+            throw new Error("SsoFactoryConfig must include id");
+    }
+}
+exports.SSOFactory = SSOFactory;

package/dist/src/factories/ssoGroupFactory.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SsoGroupFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const createAwsIdentitystoreGroup_1 = require("./createAwsIdentitystoreGroup");
+const createAwsIdentitystoreGroupMembership_1 = require("./createAwsIdentitystoreGroupMembership");
+class SsoGroupFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config) {
+        if (config.hooks?.beforeCreateResources)
+            await config.hooks.beforeCreateResources(config);
+        const group = (0, createAwsIdentitystoreGroup_1.createAwsIdentitystoreGroup)(config.configuration);
+        let memberships = [];
+        if (config.configuration.members && config.configuration.members.length > 0) {
+            memberships = config.configuration.members.map((userId, idx) => group.id.apply(groupId => {
+                const groupName = config.configuration.displayName.replace(/[^a-zA-Z0-9-_]/g, "-");
+                const membershipName = `${groupName}-membership-${idx}`;
+                return (0, createAwsIdentitystoreGroupMembership_1.createAwsIdentitystoreGroupMembership)(config.configuration.identityStoreId, groupId, userId, membershipName);
+            }));
+        }
+        const resources = { group, memberships };
+        if (config.hooks?.afterCreateResources)
+            await config.hooks.afterCreateResources(resources, config);
+        return resources;
+    }
+    getOutputs(resource) {
+        return {
+            id: resource.group.id,
+            arn: resource.group.arn,
+            memberships: resource.memberships
+        };
+    }
+    validateConfig(config) {
+        if (!config.id)
+            throw new Error("SsoGroupFactoryConfig must include id");
+        if (!config.configuration.displayName)
+            throw new Error("Group must have displayName");
+        if (!config.configuration.identityStoreId)
+            throw new Error("Group must have identityStoreId");
+    }
+}
+exports.SsoGroupFactory = SsoGroupFactory;

package/dist/src/factories/ssoPermissionSetFactory.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSOPermissionSetFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const createAwsSsoPermissionSet_1 = require("./createAwsSsoPermissionSet");
+class SSOPermissionSetFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config) {
+        const arr = Array.isArray(config.configuration) ? config.configuration : [config.configuration];
+        const resources = arr.map(ps => (0, createAwsSsoPermissionSet_1.createAwsSsoPermissionSet)(ps));
+        return resources;
+    }
+    getOutputs(resources) {
+        const out = {
+            arns: resources.map(r => r.arn),
+            permissionSets: resources
+        };
+        if (resources.length === 1) {
+            out.arn = resources[0].arn;
+        }
+        return out;
+    }
+    validateConfig(config) {
+        if (!config.id)
+            throw new Error("SsoPermissionSetFactoryConfig must include id");
+        if (!config.configuration || (typeof config.configuration !== 'object'))
+            throw new Error("configuration must be an object or array");
+    }
+}
+exports.SSOPermissionSetFactory = SSOPermissionSetFactory;

package/dist/src/factories/ssoUserFactory.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SsoUserFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const createAwsIdentitystoreUser_1 = require("./createAwsIdentitystoreUser");
+class SsoUserFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config) {
+        if (config.hooks?.beforeCreateResources)
+            await config.hooks.beforeCreateResources(config);
+        const user = (0, createAwsIdentitystoreUser_1.createAwsIdentitystoreUser)(config.configuration);
+        if (config.hooks?.afterCreateResources)
+            await config.hooks.afterCreateResources(user, config);
+        return user;
+    }
+    getOutputs(resource) {
+        return {
+            id: resource.id,
+            arn: resource.arn
+        };
+    }
+    validateConfig(config) {
+        if (!config.id)
+            throw new Error("SsoUserFactoryConfig must include id");
+        if (!config.configuration.userName)
+            throw new Error("User must have userName");
+        if (!config.configuration.identityStoreId)
+            throw new Error("User must have identityStoreId");
+    }
+}
+exports.SsoUserFactory = SsoUserFactory;

package/dist/src/factories/stepFunctionsFactory.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepFunctionsFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const validateStepFunctionsConfig_1 = require("./validateStepFunctionsConfig");
+const createAwsStepFunctionsStateMachine_1 = require("./createAwsStepFunctionsStateMachine");
+class StepFunctionsFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config) {
+        (0, validateStepFunctionsConfig_1.validateStepFunctionsConfig)(config);
+        return (0, createAwsStepFunctionsStateMachine_1.createAwsStepFunctionsStateMachine)(config.configuration.name, {
+            name: config.configuration.name,
+            definition: JSON.stringify(config.configuration.definition),
+            roleArn: config.configuration.roleArn,
+            type: config.configuration.type || config.configuration.stateMachineType,
+            loggingConfiguration: config.configuration.loggingConfiguration,
+            tracingConfiguration: config.configuration.tracingConfiguration,
+            tags: config.configuration.tags,
+            publish: config.configuration.publish,
+            encryptionConfiguration: config.configuration.encryptionConfiguration,
+        });
+    }
+    getOutputs(resource) {
+        return {
+            arn: resource.arn,
+            name: resource.name,
+        };
+    }
+    validateConfig(config) {
+        (0, validateStepFunctionsConfig_1.validateStepFunctionsConfig)(config);
+    }
+}
+exports.StepFunctionsFactory = StepFunctionsFactory;

package/dist/src/factories/tagPolicies.js

@@ -0,0 +1,99 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagPolicies = void 0;
+const aws = __importStar(require("@pulumi/aws"));
+const pulumi = __importStar(require("@pulumi/pulumi"));
+class TagPolicies extends pulumi.ComponentResource {
+    orgId;
+    costCenters;
+    constructor(name, args, opts) {
+        super("acme:policies:TagPolicy", name, undefined, opts);
+        this.orgId = args.orgId;
+        this.costCenters = args.costCenters;
+        this.createOrgTagPolicy();
+        this.createTagPolicyForOrgUnits();
+        super.registerOutputs();
+    }
+    createOrgTagPolicy() {
+        const orgTagPolicy = new aws.organizations.Policy("orgTagPolicy", {
+            type: "TAG_POLICY",
+            content: JSON.stringify({
+                tags: {
+                    CostCenter: {
+                        tag_key: {
+                            "@@assign": "CostCenter",
+                            "@@operators_allowed_for_child_policies": ["@@none"],
+                        },
+                    },
+                },
+            }),
+        }, { parent: this });
+        const attachment = new aws.organizations.PolicyAttachment("orgTagPolicyAttachment", {
+            policyId: orgTagPolicy.id,
+            targetId: this.orgId,
+        }, { parent: this });
+    }
+    createTagPolicyForOrgUnits() {
+        this.costCenters.forEach(this.createOrgUnitTagPolicy.bind(this));
+    }
+    createOrgUnitTagPolicy(costCenter) {
+        costCenter.ou.name.apply((name) => {
+            const orgTagPolicy = new aws.organizations.Policy(`${name}TagPolicy`, {
+                type: "TAG_POLICY",
+                content: JSON.stringify({
+                    tags: {
+                        CostCenter: {
+                            tag_value: {
+                                "@@assign": costCenter.allowedCostCenters,
+                            },
+                        },
+                        Owner: {
+                            tag_key: {
+                                "@@assign": "Owner",
+                                "@@operators_allowed_for_child_policies": ["@@none"],
+                            },
+                        },
+                    },
+                }),
+            }, { parent: this });
+            const attachment = new aws.organizations.PolicyAttachment(`${name}TagPolicyAttachment`, {
+                policyId: orgTagPolicy.id,
+                targetId: costCenter.ou.id,
+            }, { parent: this });
+        });
+    }
+}
+exports.TagPolicies = TagPolicies;

package/dist/src/factories/transformBudgetCostFilters.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformBudgetCostFilters = transformBudgetCostFilters;
+function transformBudgetCostFilters(costFilters) {
+    if (!costFilters)
+        return undefined;
+    return Object.entries(costFilters).map(([name, values]) => ({ name, values }));
+}

package/dist/src/factories/transformBudgetNotifications.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformBudgetNotifications = transformBudgetNotifications;
+function transformBudgetNotifications(notifications) {
+    return notifications?.map((n) => ({
+        notificationType: n.type,
+        threshold: n.threshold,
+        thresholdType: n.thresholdType,
+        comparisonOperator: n.comparisonOperator,
+        subscriberEmailAddresses: n.emailAddresses,
+    })) ?? undefined;
+}

package/dist/src/factories/transformBudgetPlannedLimits.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformBudgetPlannedLimits = transformBudgetPlannedLimits;
+function transformBudgetPlannedLimits(plannedLimits) {
+    if (!plannedLimits)
+        return undefined;
+    return plannedLimits.map(l => ({ startTime: l.startTime, amount: l.amount, unit: l.unit }));
+}

package/dist/src/factories/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/factories/validateAcmConfig.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAcmConfig = validateAcmConfig;
+function validateAcmConfig(config) {
+    if (!config.configuration || !config.configuration.domainName) {
+        throw new Error("ACM config must include configuration with domainName");
+    }
+    if (config.configuration.validationMethod && typeof config.configuration.validationMethod !== "string") {
+        throw new Error("validationMethod must be a string");
+    }
+    if (config.configuration.subjectAlternativeNames && !Array.isArray(config.configuration.subjectAlternativeNames)) {
+        throw new Error("subjectAlternativeNames must be an array");
+    }
+    if (config.configuration.tags && typeof config.configuration.tags !== "object") {
+        throw new Error("tags must be an object");
+    }
+    if (config.configuration.options && typeof config.configuration.options !== "object") {
+        throw new Error("options must be an object");
+    }
+    if (config.configuration.domainValidationOptions && !Array.isArray(config.configuration.domainValidationOptions)) {
+        throw new Error("domainValidationOptions must be an array");
+    }
+    if (config.configuration.keyAlgorithm && typeof config.configuration.keyAlgorithm !== "string") {
+        throw new Error("keyAlgorithm must be a string");
+    }
+}

package/dist/src/factories/validateAuroraConfig.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAuroraConfig = validateAuroraConfig;
+function validateAuroraConfig(config) {
+    if (!config.configuration || !config.configuration.engine) {
+        throw new Error("Aurora config must include configuration with engine");
+    }
+}