@fractal_cloud/sdk 1.0.0 → 1.1.0

package/dist/index.mjs

@@ -473,7 +473,7 @@ let ServiceDeliveryModel$1 = /* @__PURE__ */ function(ServiceDeliveryModel) {
 *                     if the string is valid.
 */
 const isValidPascalCaseString = (value) => {
-	if (!/^[A-Z][a-zA-Z]*$/.test(value)) return [` Value '${value}' must be in PascalCase`];
+	if (!/^[A-Z][a-zA-Z0-9]*$/.test(value)) return [` Value '${value}' must be in PascalCase`];
 	return [];
 };
 /**
@@ -1145,7 +1145,7 @@ const CLIENT_SECRET_HEADER$1 = "X-ClientSecret";
 const FRACTAL_API_URL$1 = "https://api.fractal.cloud";
 const deployFractal = async (credentials, fractal) => {
 	const fractalUrl = `${FRACTAL_API_URL$1}/blueprints/${fractal.id.toString().replace(":", "/")}`;
-	((await superagent.get(fractalUrl).set(CLIENT_ID_HEADER$1, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER$1, credentials.secret).send()).status === 200 ? superagent.put(fractalUrl) : superagent.post(fractalUrl)).set(CLIENT_ID_HEADER$1, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER$1, credentials.secret).send({
+	((await superagent.get(fractalUrl).ok((res) => res.status === 200 || res.status === 404).set(CLIENT_ID_HEADER$1, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER$1, credentials.secret).send()).status === 200 ? superagent.put(fractalUrl) : superagent.post(fractalUrl)).set(CLIENT_ID_HEADER$1, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER$1, credentials.secret).send({
 		description: fractal.description,
 		isPrivate: fractal.isPrivate,
 		components: fractal.components.map((c) => ({
@@ -1213,7 +1213,8 @@ const DEFAULT_FRACTAL = {
 const isValidFractal = (fractal) => {
 	const idErrors = addContextToErrors$4(fractal.id, isValidFractalId(fractal.id));
 	const componentsErrors = addContextToErrors$4(fractal.id, !fractal.components || fractal.components.length === 0 ? ["[Components] Components must not be empty"] : fractal.components.reduce((acc, x) => {
-		acc.push(...isValidBlueprintComponent(x));
+		if ("provider" in x) acc.push(`[Component: ${x.id.toString()}] Live system components cannot be added to a Fractal blueprint. Use LiveSystem.withComponent() instead.`);
+		else acc.push(...isValidBlueprintComponent(x));
 		return acc;
 	}, []));
 	return [...idErrors, ...componentsErrors];
@@ -1838,7 +1839,7 @@ const deployLiveSystem = async (credentials, liveSystem) => {
 		}
 	};
 	const liveSystemUrl = `${FRACTAL_API_URL}/livesystems/${liveSystem.id.toString()}`;
-	((await superagent.get(liveSystemUrl).set(CLIENT_ID_HEADER, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER, credentials.secret).send()).status === 200 ? superagent.put(liveSystemUrl) : superagent.post(`${FRACTAL_API_URL}/livesystems`)).set(CLIENT_ID_HEADER, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER, credentials.secret).send(body).catch((e) => console.error(e.message, e.response.text));
+	((await superagent.get(liveSystemUrl).ok((res) => res.status === 200 || res.status === 404).set(CLIENT_ID_HEADER, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER, credentials.secret).send()).status === 200 ? superagent.put(liveSystemUrl) : superagent.post(`${FRACTAL_API_URL}/livesystems`)).set(CLIENT_ID_HEADER, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER, credentials.secret).send(body).catch((e) => console.error(e.message, e.response.text));
 };
 const destroyLiveSystem = async (credentials, id) => {
 	await superagent.delete(`${FRACTAL_API_URL}/livesystems/${id.toString()}`).set(CLIENT_ID_HEADER, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER, credentials.secret);
@@ -2009,6 +2010,2515 @@ let LiveSystem$1;
 	_LiveSystem.getBuilder = getLiveSystemBuilder;
 })(LiveSystem$1 || (LiveSystem$1 = {}));
 
+//#endregion
+//#region src/fractal/component/network_and_compute/iaas/virtual_network.ts
+const VIRTUAL_NETWORK_TYPE_NAME = "VirtualNetwork";
+const CIDR_BLOCK_PARAM$1 = "cidrBlock";
+function buildId$28(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$28(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildVirtualNetworkType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(VIRTUAL_NETWORK_TYPE_NAME).build()).build();
+}
+function pushParam$25(params, key, value) {
+	params.push(key, value);
+}
+function makeVirtualNetworkNode(vpc, subnetNodes, sgs) {
+	const vpcDep = { id: vpc.id };
+	const wiredSubnets = subnetNodes.map((n) => ({
+		...n.subnet,
+		dependencies: [...n.subnet.dependencies, vpcDep]
+	}));
+	const wiredSgs = sgs.map((sg) => ({
+		...sg,
+		dependencies: [vpcDep]
+	}));
+	const allVMs = subnetNodes.flatMap((n) => n.virtualMachines);
+	const allEcsSvcs = subnetNodes.flatMap((n) => n.workloads);
+	return {
+		vpc,
+		subnets: wiredSubnets,
+		securityGroups: wiredSgs,
+		virtualMachines: allVMs,
+		workloads: allEcsSvcs,
+		components: [
+			vpc,
+			...wiredSubnets,
+			...wiredSgs,
+			...allVMs,
+			...allEcsSvcs
+		],
+		withSubnets: (newSubnets) => makeVirtualNetworkNode(vpc, newSubnets, sgs),
+		withSecurityGroups: (newSgs) => makeVirtualNetworkNode(vpc, subnetNodes, newSgs)
+	};
+}
+let VirtualNetwork;
+(function(_VirtualNetwork) {
+	const getBuilder = _VirtualNetwork.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getBlueprintComponentBuilder().withType(buildVirtualNetworkType()).withParameters(params);
+		const subnetBuilders = [];
+		const sgBuilders = [];
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$28(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$28(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withCidrBlock: (value) => {
+				pushParam$25(params, CIDR_BLOCK_PARAM$1, value);
+				return builder;
+			},
+			withSubnet: (subnetBuilder) => {
+				subnetBuilders.push(subnetBuilder);
+				return builder;
+			},
+			withSecurityGroup: (sgBuilder) => {
+				sgBuilders.push(sgBuilder);
+				return builder;
+			},
+			withLinks: (links) => {
+				inner.withLinks(links);
+				return builder;
+			},
+			build: () => {
+				const vpc = inner.build();
+				const vpcDep = { id: vpc.id };
+				const subnetResults = subnetBuilders.map((b) => b.build());
+				const subnets = subnetResults.map((r) => ({
+					...r.subnet,
+					dependencies: [...r.subnet.dependencies, vpcDep]
+				}));
+				const virtualMachines = subnetResults.flatMap((r) => r.virtualMachines);
+				const securityGroups = sgBuilders.map((b) => ({
+					...b.build(),
+					dependencies: [vpcDep]
+				}));
+				return {
+					vpc,
+					subnets,
+					securityGroups,
+					virtualMachines,
+					components: [
+						vpc,
+						...subnets,
+						...securityGroups,
+						...virtualMachines
+					]
+				};
+			}
+		};
+		return builder;
+	};
+	_VirtualNetwork.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName);
+		if (config.cidrBlock) b.withCidrBlock(config.cidrBlock);
+		if (config.description) b.withDescription(config.description);
+		return makeVirtualNetworkNode(b.build().vpc, [], []);
+	};
+})(VirtualNetwork || (VirtualNetwork = {}));
+
+//#endregion
+//#region src/fractal/component/network_and_compute/iaas/subnet.ts
+const SUBNET_TYPE_NAME = "Subnet";
+const CIDR_BLOCK_PARAM = "cidrBlock";
+function buildId$27(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$27(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildSubnetType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(SUBNET_TYPE_NAME).build()).build();
+}
+function pushParam$24(params, key, value) {
+	params.push(key, value);
+}
+function makeSubnetNode(subnet, vms, workloadNodes) {
+	const subnetDep = { id: subnet.id };
+	const wiredVMs = vms.map((n) => ({
+		...n.component,
+		dependencies: [...n.component.dependencies, subnetDep]
+	}));
+	const wiredWorkloads = workloadNodes.map((w) => ({
+		...w.component,
+		dependencies: [...w.component.dependencies, subnetDep]
+	}));
+	return {
+		subnet,
+		virtualMachines: wiredVMs,
+		workloads: wiredWorkloads,
+		components: [
+			subnet,
+			...wiredVMs,
+			...wiredWorkloads
+		],
+		withVirtualMachines: (newVMs) => makeSubnetNode(subnet, newVMs, workloadNodes),
+		withWorkloads: (newWorkloads) => makeSubnetNode(subnet, vms, newWorkloads)
+	};
+}
+let Subnet;
+(function(_Subnet) {
+	const getBuilder = _Subnet.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getBlueprintComponentBuilder().withType(buildSubnetType()).withParameters(params);
+		const vmBuilders = [];
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$27(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$27(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withCidrBlock: (value) => {
+				pushParam$24(params, CIDR_BLOCK_PARAM, value);
+				return builder;
+			},
+			withVirtualMachine: (vmBuilder) => {
+				vmBuilders.push(vmBuilder);
+				return builder;
+			},
+			withLinks: (links) => {
+				inner.withLinks(links);
+				return builder;
+			},
+			build: () => {
+				const subnet = inner.build();
+				const subnetDep = { id: subnet.id };
+				const virtualMachines = vmBuilders.map((b) => ({
+					...b.build(),
+					dependencies: [subnetDep]
+				}));
+				return {
+					subnet,
+					virtualMachines,
+					components: [subnet, ...virtualMachines]
+				};
+			}
+		};
+		return builder;
+	};
+	_Subnet.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName);
+		if (config.cidrBlock) b.withCidrBlock(config.cidrBlock);
+		if (config.description) b.withDescription(config.description);
+		return makeSubnetNode(b.build().subnet, [], []);
+	};
+})(Subnet || (Subnet = {}));
+
+//#endregion
+//#region src/fractal/component/network_and_compute/iaas/security_group.ts
+const SECURITY_GROUP_TYPE_NAME = "SecurityGroup";
+const DESCRIPTION_PARAM = "description";
+const INGRESS_RULES_PARAM = "ingressRules";
+function buildId$26(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$26(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildSecurityGroupType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(SECURITY_GROUP_TYPE_NAME).build()).build();
+}
+function pushParam$23(params, key, value) {
+	params.push(key, value);
+}
+let SecurityGroup;
+(function(_SecurityGroup) {
+	const getBuilder = _SecurityGroup.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getBlueprintComponentBuilder().withType(buildSecurityGroupType()).withParameters(params);
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$26(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$26(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				pushParam$23(params, DESCRIPTION_PARAM, description);
+				return builder;
+			},
+			withIngressRules: (rules) => {
+				pushParam$23(params, INGRESS_RULES_PARAM, rules);
+				return builder;
+			},
+			withLinks: (links) => {
+				inner.withLinks(links);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_SecurityGroup.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withDescription(config.description);
+		if (config.ingressRules && config.ingressRules.length > 0) b.withIngressRules(config.ingressRules);
+		return b.build();
+	};
+})(SecurityGroup || (SecurityGroup = {}));
+
+//#endregion
+//#region src/fractal/component/network_and_compute/iaas/vm.ts
+const VIRTUAL_MACHINE_TYPE_NAME = "VirtualMachine";
+function buildId$25(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$25(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildVirtualMachineType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(VIRTUAL_MACHINE_TYPE_NAME).build()).build();
+}
+function buildLinkParams$1(link) {
+	const params = getParametersInstance();
+	params.push("fromPort", link.fromPort);
+	if (link.toPort !== void 0) params.push("toPort", link.toPort);
+	if (link.protocol) params.push("protocol", link.protocol);
+	return params;
+}
+function makeVirtualMachineNode(component) {
+	return {
+		component,
+		components: [component],
+		withLinks: (links) => {
+			const componentLinks = links.map((l) => getLinkBuilder().withId(l.target.component.id).withType(buildVirtualMachineType()).withParameters(buildLinkParams$1(l)).build());
+			return makeVirtualMachineNode({
+				...component,
+				links: [...component.links, ...componentLinks]
+			});
+		}
+	};
+}
+let VirtualMachine;
+(function(_VirtualMachine) {
+	const getBuilder = _VirtualMachine.getBuilder = () => {
+		const inner = getBlueprintComponentBuilder().withType(buildVirtualMachineType()).withParameters(getParametersInstance());
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$25(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$25(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withLinks: (links) => {
+				inner.withLinks(links);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_VirtualMachine.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName);
+		if (config.description) b.withDescription(config.description);
+		return makeVirtualMachineNode(b.build());
+	};
+})(VirtualMachine || (VirtualMachine = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/vpc.ts
+const AWS_VPC_TYPE_NAME = "AwsVpc";
+const INSTANCE_TENANCY_PARAM = "instanceTenancy";
+const ENABLE_DNS_SUPPORT_PARAM = "enableDnsSupport";
+const ENABLE_DNS_HOSTNAMES_PARAM = "enableDnsHostnames";
+function buildId$24(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$24(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildAwsVpcType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(AWS_VPC_TYPE_NAME).build()).build();
+}
+function pushParam$22(params, key, value) {
+	params.push(key, value);
+}
+let AwsVpc;
+(function(_AwsVpc) {
+	const getBuilder = _AwsVpc.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAwsVpcType()).withParameters(params).withProvider("AWS");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$24(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$24(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withCidrBlock: (value) => {
+				pushParam$22(params, CIDR_BLOCK_PARAM$1, value);
+				return builder;
+			},
+			withInstanceTenancy: (value) => {
+				pushParam$22(params, INSTANCE_TENANCY_PARAM, value);
+				return builder;
+			},
+			withEnableDnsSupport: (value) => {
+				pushParam$22(params, ENABLE_DNS_SUPPORT_PARAM, value);
+				return builder;
+			},
+			withEnableDnsHostnames: (value) => {
+				pushParam$22(params, ENABLE_DNS_HOSTNAMES_PARAM, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_AwsVpc.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAwsVpcType()).withParameters(params).withProvider("AWS").withId(buildId$24(blueprint.id.toString())).withVersion(buildVersion$24(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const cidrBlock = blueprint.parameters.getOptionalFieldByName(CIDR_BLOCK_PARAM$1);
+		if (cidrBlock !== null) pushParam$22(params, CIDR_BLOCK_PARAM$1, String(cidrBlock));
+		const satisfiedBuilder = {
+			withInstanceTenancy: (value) => {
+				pushParam$22(params, INSTANCE_TENANCY_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withEnableDnsSupport: (value) => {
+				pushParam$22(params, ENABLE_DNS_SUPPORT_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withEnableDnsHostnames: (value) => {
+				pushParam$22(params, ENABLE_DNS_HOSTNAMES_PARAM, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_AwsVpc.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withCidrBlock(config.cidrBlock);
+		if (config.description) b.withDescription(config.description);
+		if (config.instanceTenancy) b.withInstanceTenancy(config.instanceTenancy);
+		if (config.enableDnsSupport !== void 0) b.withEnableDnsSupport(config.enableDnsSupport);
+		if (config.enableDnsHostnames !== void 0) b.withEnableDnsHostnames(config.enableDnsHostnames);
+		return b.build();
+	};
+})(AwsVpc || (AwsVpc = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/subnet.ts
+const AWS_SUBNET_TYPE_NAME = "AwsSubnet";
+const AVAILABILITY_ZONE_PARAM = "availabilityZone";
+function buildId$23(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$23(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildAwsSubnetType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(AWS_SUBNET_TYPE_NAME).build()).build();
+}
+function pushParam$21(params, key, value) {
+	params.push(key, value);
+}
+let AwsSubnet;
+(function(_AwsSubnet) {
+	const getBuilder = _AwsSubnet.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAwsSubnetType()).withParameters(params).withProvider("AWS");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$23(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$23(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withCidrBlock: (value) => {
+				pushParam$21(params, CIDR_BLOCK_PARAM, value);
+				return builder;
+			},
+			withAvailabilityZone: (value) => {
+				pushParam$21(params, AVAILABILITY_ZONE_PARAM, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_AwsSubnet.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAwsSubnetType()).withParameters(params).withProvider("AWS").withId(buildId$23(blueprint.id.toString())).withVersion(buildVersion$23(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const cidrBlock = blueprint.parameters.getOptionalFieldByName(CIDR_BLOCK_PARAM);
+		if (cidrBlock !== null) pushParam$21(params, CIDR_BLOCK_PARAM, String(cidrBlock));
+		const satisfiedBuilder = {
+			withAvailabilityZone: (value) => {
+				pushParam$21(params, AVAILABILITY_ZONE_PARAM, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_AwsSubnet.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withCidrBlock(config.cidrBlock).withAvailabilityZone(config.availabilityZone);
+		if (config.description) b.withDescription(config.description);
+		return b.build();
+	};
+})(AwsSubnet || (AwsSubnet = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/security_group.ts
+const AWS_SG_TYPE_NAME = "AwsSecurityGroup";
+function buildId$22(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$22(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildAwsSgType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(AWS_SG_TYPE_NAME).build()).build();
+}
+function pushParam$20(params, key, value) {
+	params.push(key, value);
+}
+let AwsSecurityGroup;
+(function(_AwsSecurityGroup) {
+	const getBuilder = _AwsSecurityGroup.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAwsSgType()).withParameters(params).withProvider("AWS");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$22(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$22(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				pushParam$20(params, DESCRIPTION_PARAM, description);
+				return builder;
+			},
+			withIngressRules: (rules) => {
+				pushParam$20(params, INGRESS_RULES_PARAM, rules);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_AwsSecurityGroup.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAwsSgType()).withParameters(params).withProvider("AWS").withId(buildId$22(blueprint.id.toString())).withVersion(buildVersion$22(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		const description = blueprint.parameters.getOptionalFieldByName(DESCRIPTION_PARAM);
+		if (description !== null) {
+			inner.withDescription(String(description));
+			pushParam$20(params, DESCRIPTION_PARAM, String(description));
+		} else if (blueprint.description) inner.withDescription(blueprint.description);
+		const ingressRules = blueprint.parameters.getOptionalFieldByName(INGRESS_RULES_PARAM);
+		if (ingressRules !== null) pushParam$20(params, INGRESS_RULES_PARAM, ingressRules);
+		return { build: () => inner.build() };
+	};
+	_AwsSecurityGroup.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withDescription(config.description);
+		if (config.ingressRules && config.ingressRules.length > 0) b.withIngressRules(config.ingressRules);
+		return b.build();
+	};
+})(AwsSecurityGroup || (AwsSecurityGroup = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/ec2_instance.ts
+const EC2_TYPE_NAME = "EC2";
+const AMI_ID_PARAM = "amiId";
+const INSTANCE_TYPE_PARAM = "instanceType";
+const KEY_NAME_PARAM = "keyName";
+const USER_DATA_PARAM$1 = "userData";
+const IAM_INSTANCE_PROFILE_PARAM = "iamInstanceProfile";
+const ASSOCIATE_PUBLIC_IP_PARAM = "associatePublicIp";
+function buildId$21(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$21(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildEc2Type() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(EC2_TYPE_NAME).build()).build();
+}
+function pushParam$19(params, key, value) {
+	params.push(key, value);
+}
+let Ec2Instance;
+(function(_Ec2Instance) {
+	const getBuilder = _Ec2Instance.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildEc2Type()).withParameters(params).withProvider("AWS");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$21(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$21(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withAmiId: (value) => {
+				pushParam$19(params, AMI_ID_PARAM, value);
+				return builder;
+			},
+			withInstanceType: (value) => {
+				pushParam$19(params, INSTANCE_TYPE_PARAM, value);
+				return builder;
+			},
+			withKeyName: (value) => {
+				pushParam$19(params, KEY_NAME_PARAM, value);
+				return builder;
+			},
+			withUserData: (value) => {
+				pushParam$19(params, USER_DATA_PARAM$1, value);
+				return builder;
+			},
+			withIamInstanceProfile: (value) => {
+				pushParam$19(params, IAM_INSTANCE_PROFILE_PARAM, value);
+				return builder;
+			},
+			withAssociatePublicIp: (value) => {
+				pushParam$19(params, ASSOCIATE_PUBLIC_IP_PARAM, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_Ec2Instance.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildEc2Type()).withParameters(params).withProvider("AWS").withId(buildId$21(blueprint.id.toString())).withVersion(buildVersion$21(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const satisfiedBuilder = {
+			withAmiId: (value) => {
+				pushParam$19(params, AMI_ID_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withInstanceType: (value) => {
+				pushParam$19(params, INSTANCE_TYPE_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withKeyName: (value) => {
+				pushParam$19(params, KEY_NAME_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withUserData: (value) => {
+				pushParam$19(params, USER_DATA_PARAM$1, value);
+				return satisfiedBuilder;
+			},
+			withIamInstanceProfile: (value) => {
+				pushParam$19(params, IAM_INSTANCE_PROFILE_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withAssociatePublicIp: (value) => {
+				pushParam$19(params, ASSOCIATE_PUBLIC_IP_PARAM, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_Ec2Instance.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withAmiId(config.amiId).withInstanceType(config.instanceType);
+		if (config.description) b.withDescription(config.description);
+		if (config.keyName) b.withKeyName(config.keyName);
+		if (config.userData) b.withUserData(config.userData);
+		if (config.iamInstanceProfile) b.withIamInstanceProfile(config.iamInstanceProfile);
+		if (config.associatePublicIp !== void 0) b.withAssociatePublicIp(config.associatePublicIp);
+		return b.build();
+	};
+})(Ec2Instance || (Ec2Instance = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/azure_vnet.ts
+const AZURE_VNET_TYPE_NAME = "AzureVnet";
+const LOCATION_PARAM$3 = "location";
+const RESOURCE_GROUP_PARAM$3 = "resourceGroup";
+function buildId$20(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$20(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildAzureVnetType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(AZURE_VNET_TYPE_NAME).build()).build();
+}
+function pushParam$18(params, key, value) {
+	params.push(key, value);
+}
+let AzureVnet;
+(function(_AzureVnet) {
+	const getBuilder = _AzureVnet.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAzureVnetType()).withParameters(params).withProvider("Azure");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$20(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$20(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withCidrBlock: (value) => {
+				pushParam$18(params, CIDR_BLOCK_PARAM$1, value);
+				return builder;
+			},
+			withLocation: (value) => {
+				pushParam$18(params, LOCATION_PARAM$3, value);
+				return builder;
+			},
+			withResourceGroup: (value) => {
+				pushParam$18(params, RESOURCE_GROUP_PARAM$3, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_AzureVnet.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAzureVnetType()).withParameters(params).withProvider("Azure").withId(buildId$20(blueprint.id.toString())).withVersion(buildVersion$20(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const cidrBlock = blueprint.parameters.getOptionalFieldByName(CIDR_BLOCK_PARAM$1);
+		if (cidrBlock !== null) pushParam$18(params, CIDR_BLOCK_PARAM$1, String(cidrBlock));
+		const satisfiedBuilder = {
+			withLocation: (value) => {
+				pushParam$18(params, LOCATION_PARAM$3, value);
+				return satisfiedBuilder;
+			},
+			withResourceGroup: (value) => {
+				pushParam$18(params, RESOURCE_GROUP_PARAM$3, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_AzureVnet.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withCidrBlock(config.cidrBlock).withLocation(config.location).withResourceGroup(config.resourceGroup);
+		if (config.description) b.withDescription(config.description);
+		return b.build();
+	};
+})(AzureVnet || (AzureVnet = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/azure_subnet.ts
+const AZURE_SUBNET_TYPE_NAME = "AzureSubnet";
+const RESOURCE_GROUP_PARAM$2 = "resourceGroup";
+function buildId$19(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$19(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildAzureSubnetType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(AZURE_SUBNET_TYPE_NAME).build()).build();
+}
+function pushParam$17(params, key, value) {
+	params.push(key, value);
+}
+let AzureSubnet;
+(function(_AzureSubnet) {
+	const getBuilder = _AzureSubnet.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAzureSubnetType()).withParameters(params).withProvider("Azure");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$19(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$19(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withCidrBlock: (value) => {
+				pushParam$17(params, CIDR_BLOCK_PARAM, value);
+				return builder;
+			},
+			withResourceGroup: (value) => {
+				pushParam$17(params, RESOURCE_GROUP_PARAM$2, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_AzureSubnet.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAzureSubnetType()).withParameters(params).withProvider("Azure").withId(buildId$19(blueprint.id.toString())).withVersion(buildVersion$19(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const cidrBlock = blueprint.parameters.getOptionalFieldByName(CIDR_BLOCK_PARAM);
+		if (cidrBlock !== null) pushParam$17(params, CIDR_BLOCK_PARAM, String(cidrBlock));
+		const satisfiedBuilder = {
+			withResourceGroup: (value) => {
+				pushParam$17(params, RESOURCE_GROUP_PARAM$2, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_AzureSubnet.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withCidrBlock(config.cidrBlock).withResourceGroup(config.resourceGroup);
+		if (config.description) b.withDescription(config.description);
+		return b.build();
+	};
+})(AzureSubnet || (AzureSubnet = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/azure_nsg.ts
+const AZURE_NSG_TYPE_NAME = "AzureNsg";
+const LOCATION_PARAM$2 = "location";
+const RESOURCE_GROUP_PARAM$1 = "resourceGroup";
+function buildId$18(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$18(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildAzureNsgType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(AZURE_NSG_TYPE_NAME).build()).build();
+}
+function pushParam$16(params, key, value) {
+	params.push(key, value);
+}
+let AzureNsg;
+(function(_AzureNsg) {
+	const getBuilder = _AzureNsg.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAzureNsgType()).withParameters(params).withProvider("Azure");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$18(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$18(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				pushParam$16(params, DESCRIPTION_PARAM, description);
+				return builder;
+			},
+			withIngressRules: (rules) => {
+				pushParam$16(params, INGRESS_RULES_PARAM, rules);
+				return builder;
+			},
+			withLocation: (value) => {
+				pushParam$16(params, LOCATION_PARAM$2, value);
+				return builder;
+			},
+			withResourceGroup: (value) => {
+				pushParam$16(params, RESOURCE_GROUP_PARAM$1, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_AzureNsg.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAzureNsgType()).withParameters(params).withProvider("Azure").withId(buildId$18(blueprint.id.toString())).withVersion(buildVersion$18(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		const description = blueprint.parameters.getOptionalFieldByName(DESCRIPTION_PARAM);
+		if (description !== null) {
+			inner.withDescription(String(description));
+			pushParam$16(params, DESCRIPTION_PARAM, String(description));
+		} else if (blueprint.description) inner.withDescription(blueprint.description);
+		const ingressRules = blueprint.parameters.getOptionalFieldByName(INGRESS_RULES_PARAM);
+		if (ingressRules !== null) pushParam$16(params, INGRESS_RULES_PARAM, ingressRules);
+		const satisfiedBuilder = {
+			withLocation: (value) => {
+				pushParam$16(params, LOCATION_PARAM$2, value);
+				return satisfiedBuilder;
+			},
+			withResourceGroup: (value) => {
+				pushParam$16(params, RESOURCE_GROUP_PARAM$1, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_AzureNsg.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withLocation(config.location).withResourceGroup(config.resourceGroup);
+		if (config.description) b.withDescription(config.description);
+		if (config.ingressRules && config.ingressRules.length > 0) b.withIngressRules(config.ingressRules);
+		return b.build();
+	};
+})(AzureNsg || (AzureNsg = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/azure_vm.ts
+const AZURE_VM_TYPE_NAME = "AzureVm";
+const VM_SIZE_PARAM = "vmSize";
+const LOCATION_PARAM$1 = "location";
+const RESOURCE_GROUP_PARAM = "resourceGroup";
+const ADMIN_USERNAME_PARAM = "adminUsername";
+const IMAGE_PUBLISHER_PARAM = "imagePublisher";
+const IMAGE_OFFER_PARAM = "imageOffer";
+const IMAGE_SKU_PARAM = "imageSku";
+const SSH_PUBLIC_KEY_PARAM$1 = "sshPublicKey";
+const OS_DISK_SIZE_GB_PARAM = "osDiskSizeGb";
+function buildId$17(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$17(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildAzureVmType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(AZURE_VM_TYPE_NAME).build()).build();
+}
+function pushParam$15(params, key, value) {
+	params.push(key, value);
+}
+let AzureVm;
+(function(_AzureVm) {
+	const getBuilder = _AzureVm.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAzureVmType()).withParameters(params).withProvider("Azure");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$17(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$17(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withVmSize: (value) => {
+				pushParam$15(params, VM_SIZE_PARAM, value);
+				return builder;
+			},
+			withLocation: (value) => {
+				pushParam$15(params, LOCATION_PARAM$1, value);
+				return builder;
+			},
+			withResourceGroup: (value) => {
+				pushParam$15(params, RESOURCE_GROUP_PARAM, value);
+				return builder;
+			},
+			withAdminUsername: (value) => {
+				pushParam$15(params, ADMIN_USERNAME_PARAM, value);
+				return builder;
+			},
+			withImagePublisher: (value) => {
+				pushParam$15(params, IMAGE_PUBLISHER_PARAM, value);
+				return builder;
+			},
+			withImageOffer: (value) => {
+				pushParam$15(params, IMAGE_OFFER_PARAM, value);
+				return builder;
+			},
+			withImageSku: (value) => {
+				pushParam$15(params, IMAGE_SKU_PARAM, value);
+				return builder;
+			},
+			withSshPublicKey: (value) => {
+				pushParam$15(params, SSH_PUBLIC_KEY_PARAM$1, value);
+				return builder;
+			},
+			withOsDiskSizeGb: (value) => {
+				pushParam$15(params, OS_DISK_SIZE_GB_PARAM, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_AzureVm.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAzureVmType()).withParameters(params).withProvider("Azure").withId(buildId$17(blueprint.id.toString())).withVersion(buildVersion$17(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const satisfiedBuilder = {
+			withVmSize: (value) => {
+				pushParam$15(params, VM_SIZE_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withLocation: (value) => {
+				pushParam$15(params, LOCATION_PARAM$1, value);
+				return satisfiedBuilder;
+			},
+			withResourceGroup: (value) => {
+				pushParam$15(params, RESOURCE_GROUP_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withAdminUsername: (value) => {
+				pushParam$15(params, ADMIN_USERNAME_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withImagePublisher: (value) => {
+				pushParam$15(params, IMAGE_PUBLISHER_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withImageOffer: (value) => {
+				pushParam$15(params, IMAGE_OFFER_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withImageSku: (value) => {
+				pushParam$15(params, IMAGE_SKU_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withSshPublicKey: (value) => {
+				pushParam$15(params, SSH_PUBLIC_KEY_PARAM$1, value);
+				return satisfiedBuilder;
+			},
+			withOsDiskSizeGb: (value) => {
+				pushParam$15(params, OS_DISK_SIZE_GB_PARAM, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_AzureVm.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withVmSize(config.vmSize).withLocation(config.location).withResourceGroup(config.resourceGroup).withAdminUsername(config.adminUsername).withImagePublisher(config.imagePublisher).withImageOffer(config.imageOffer).withImageSku(config.imageSku);
+		if (config.description) b.withDescription(config.description);
+		if (config.sshPublicKey) b.withSshPublicKey(config.sshPublicKey);
+		if (config.osDiskSizeGb !== void 0) b.withOsDiskSizeGb(config.osDiskSizeGb);
+		return b.build();
+	};
+})(AzureVm || (AzureVm = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/gcp_vpc.ts
+const GCP_VPC_TYPE_NAME = "GcpVpc";
+const AUTO_CREATE_SUBNETWORKS_PARAM = "autoCreateSubnetworks";
+const ROUTING_MODE_PARAM = "routingMode";
+function buildId$16(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$16(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildGcpVpcType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(GCP_VPC_TYPE_NAME).build()).build();
+}
+function pushParam$14(params, key, value) {
+	params.push(key, value);
+}
+let GcpVpc;
+(function(_GcpVpc) {
+	const getBuilder = _GcpVpc.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildGcpVpcType()).withParameters(params).withProvider("GCP");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$16(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$16(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withCidrBlock: (value) => {
+				pushParam$14(params, CIDR_BLOCK_PARAM$1, value);
+				return builder;
+			},
+			withAutoCreateSubnetworks: (value) => {
+				pushParam$14(params, AUTO_CREATE_SUBNETWORKS_PARAM, value);
+				return builder;
+			},
+			withRoutingMode: (value) => {
+				pushParam$14(params, ROUTING_MODE_PARAM, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_GcpVpc.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildGcpVpcType()).withParameters(params).withProvider("GCP").withId(buildId$16(blueprint.id.toString())).withVersion(buildVersion$16(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const cidrBlock = blueprint.parameters.getOptionalFieldByName(CIDR_BLOCK_PARAM$1);
+		if (cidrBlock !== null) pushParam$14(params, CIDR_BLOCK_PARAM$1, String(cidrBlock));
+		const satisfiedBuilder = {
+			withAutoCreateSubnetworks: (value) => {
+				pushParam$14(params, AUTO_CREATE_SUBNETWORKS_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withRoutingMode: (value) => {
+				pushParam$14(params, ROUTING_MODE_PARAM, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_GcpVpc.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withCidrBlock(config.cidrBlock);
+		if (config.description) b.withDescription(config.description);
+		if (config.autoCreateSubnetworks !== void 0) b.withAutoCreateSubnetworks(config.autoCreateSubnetworks);
+		if (config.routingMode) b.withRoutingMode(config.routingMode);
+		return b.build();
+	};
+})(GcpVpc || (GcpVpc = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/gcp_subnet.ts
+const GCP_SUBNET_TYPE_NAME = "GcpSubnet";
+const REGION_PARAM = "region";
+const PRIVATE_IP_GOOGLE_ACCESS_PARAM = "privateIpGoogleAccess";
+function buildId$15(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$15(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildGcpSubnetType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(GCP_SUBNET_TYPE_NAME).build()).build();
+}
+function pushParam$13(params, key, value) {
+	params.push(key, value);
+}
+let GcpSubnet;
+(function(_GcpSubnet) {
+	const getBuilder = _GcpSubnet.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildGcpSubnetType()).withParameters(params).withProvider("GCP");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$15(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$15(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withCidrBlock: (value) => {
+				pushParam$13(params, CIDR_BLOCK_PARAM, value);
+				return builder;
+			},
+			withRegion: (value) => {
+				pushParam$13(params, REGION_PARAM, value);
+				return builder;
+			},
+			withPrivateIpGoogleAccess: (value) => {
+				pushParam$13(params, PRIVATE_IP_GOOGLE_ACCESS_PARAM, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_GcpSubnet.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildGcpSubnetType()).withParameters(params).withProvider("GCP").withId(buildId$15(blueprint.id.toString())).withVersion(buildVersion$15(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const cidrBlock = blueprint.parameters.getOptionalFieldByName(CIDR_BLOCK_PARAM);
+		if (cidrBlock !== null) pushParam$13(params, CIDR_BLOCK_PARAM, String(cidrBlock));
+		const satisfiedBuilder = {
+			withRegion: (value) => {
+				pushParam$13(params, REGION_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withPrivateIpGoogleAccess: (value) => {
+				pushParam$13(params, PRIVATE_IP_GOOGLE_ACCESS_PARAM, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_GcpSubnet.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withCidrBlock(config.cidrBlock).withRegion(config.region);
+		if (config.description) b.withDescription(config.description);
+		if (config.privateIpGoogleAccess !== void 0) b.withPrivateIpGoogleAccess(config.privateIpGoogleAccess);
+		return b.build();
+	};
+})(GcpSubnet || (GcpSubnet = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/gcp_firewall.ts
+const GCP_FIREWALL_TYPE_NAME = "GcpFirewall";
+function buildId$14(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$14(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildGcpFirewallType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(GCP_FIREWALL_TYPE_NAME).build()).build();
+}
+function pushParam$12(params, key, value) {
+	params.push(key, value);
+}
+let GcpFirewall;
+(function(_GcpFirewall) {
+	const getBuilder = _GcpFirewall.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildGcpFirewallType()).withParameters(params).withProvider("GCP");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$14(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$14(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				pushParam$12(params, DESCRIPTION_PARAM, description);
+				return builder;
+			},
+			withIngressRules: (rules) => {
+				pushParam$12(params, INGRESS_RULES_PARAM, rules);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_GcpFirewall.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildGcpFirewallType()).withParameters(params).withProvider("GCP").withId(buildId$14(blueprint.id.toString())).withVersion(buildVersion$14(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		const description = blueprint.parameters.getOptionalFieldByName(DESCRIPTION_PARAM);
+		if (description !== null) {
+			inner.withDescription(String(description));
+			pushParam$12(params, DESCRIPTION_PARAM, String(description));
+		} else if (blueprint.description) inner.withDescription(blueprint.description);
+		const ingressRules = blueprint.parameters.getOptionalFieldByName(INGRESS_RULES_PARAM);
+		if (ingressRules !== null) pushParam$12(params, INGRESS_RULES_PARAM, ingressRules);
+		return { build: () => inner.build() };
+	};
+	_GcpFirewall.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName);
+		if (config.description) b.withDescription(config.description);
+		if (config.ingressRules && config.ingressRules.length > 0) b.withIngressRules(config.ingressRules);
+		return b.build();
+	};
+})(GcpFirewall || (GcpFirewall = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/gcp_vm.ts
+const GCP_VM_TYPE_NAME = "GcpVm";
+const MACHINE_TYPE_PARAM = "machineType";
+const ZONE_PARAM = "zone";
+const IMAGE_PROJECT_PARAM = "imageProject";
+const IMAGE_FAMILY_PARAM = "imageFamily";
+const SERVICE_ACCOUNT_EMAIL_PARAM = "serviceAccountEmail";
+function buildId$13(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$13(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildGcpVmType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(GCP_VM_TYPE_NAME).build()).build();
+}
+function pushParam$11(params, key, value) {
+	params.push(key, value);
+}
+let GcpVm;
+(function(_GcpVm) {
+	const getBuilder = _GcpVm.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildGcpVmType()).withParameters(params).withProvider("GCP");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$13(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$13(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withMachineType: (value) => {
+				pushParam$11(params, MACHINE_TYPE_PARAM, value);
+				return builder;
+			},
+			withZone: (value) => {
+				pushParam$11(params, ZONE_PARAM, value);
+				return builder;
+			},
+			withImageProject: (value) => {
+				pushParam$11(params, IMAGE_PROJECT_PARAM, value);
+				return builder;
+			},
+			withImageFamily: (value) => {
+				pushParam$11(params, IMAGE_FAMILY_PARAM, value);
+				return builder;
+			},
+			withServiceAccountEmail: (value) => {
+				pushParam$11(params, SERVICE_ACCOUNT_EMAIL_PARAM, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_GcpVm.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildGcpVmType()).withParameters(params).withProvider("GCP").withId(buildId$13(blueprint.id.toString())).withVersion(buildVersion$13(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const satisfiedBuilder = {
+			withMachineType: (value) => {
+				pushParam$11(params, MACHINE_TYPE_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withZone: (value) => {
+				pushParam$11(params, ZONE_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withImageProject: (value) => {
+				pushParam$11(params, IMAGE_PROJECT_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withImageFamily: (value) => {
+				pushParam$11(params, IMAGE_FAMILY_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withServiceAccountEmail: (value) => {
+				pushParam$11(params, SERVICE_ACCOUNT_EMAIL_PARAM, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_GcpVm.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withMachineType(config.machineType).withZone(config.zone).withImageProject(config.imageProject);
+		if (config.description) b.withDescription(config.description);
+		if (config.imageFamily) b.withImageFamily(config.imageFamily);
+		if (config.serviceAccountEmail) b.withServiceAccountEmail(config.serviceAccountEmail);
+		return b.build();
+	};
+})(GcpVm || (GcpVm = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/oci_vcn.ts
+const OCI_VCN_TYPE_NAME = "OciVcn";
+const COMPARTMENT_ID_PARAM$3 = "compartmentId";
+function buildId$12(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$12(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildOciVcnType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(OCI_VCN_TYPE_NAME).build()).build();
+}
+function pushParam$10(params, key, value) {
+	params.push(key, value);
+}
+let OciVcn;
+(function(_OciVcn) {
+	const getBuilder = _OciVcn.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildOciVcnType()).withParameters(params).withProvider("OCI");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$12(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$12(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withCidrBlock: (value) => {
+				pushParam$10(params, CIDR_BLOCK_PARAM$1, value);
+				return builder;
+			},
+			withCompartmentId: (value) => {
+				pushParam$10(params, COMPARTMENT_ID_PARAM$3, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_OciVcn.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildOciVcnType()).withParameters(params).withProvider("OCI").withId(buildId$12(blueprint.id.toString())).withVersion(buildVersion$12(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const cidrBlock = blueprint.parameters.getOptionalFieldByName(CIDR_BLOCK_PARAM$1);
+		if (cidrBlock !== null) pushParam$10(params, CIDR_BLOCK_PARAM$1, String(cidrBlock));
+		const satisfiedBuilder = {
+			withCompartmentId: (value) => {
+				pushParam$10(params, COMPARTMENT_ID_PARAM$3, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_OciVcn.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withCidrBlock(config.cidrBlock).withCompartmentId(config.compartmentId);
+		if (config.description) b.withDescription(config.description);
+		return b.build();
+	};
+})(OciVcn || (OciVcn = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/oci_subnet.ts
+const OCI_SUBNET_TYPE_NAME = "OciSubnet";
+const COMPARTMENT_ID_PARAM$2 = "compartmentId";
+const AVAILABILITY_DOMAIN_PARAM$1 = "availabilityDomain";
+const PROHIBIT_PUBLIC_IP_PARAM = "prohibitPublicIpOnVnic";
+function buildId$11(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$11(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildOciSubnetType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(OCI_SUBNET_TYPE_NAME).build()).build();
+}
+function pushParam$9(params, key, value) {
+	params.push(key, value);
+}
+let OciSubnet;
+(function(_OciSubnet) {
+	const getBuilder = _OciSubnet.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildOciSubnetType()).withParameters(params).withProvider("OCI");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$11(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$11(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withCidrBlock: (value) => {
+				pushParam$9(params, CIDR_BLOCK_PARAM, value);
+				return builder;
+			},
+			withCompartmentId: (value) => {
+				pushParam$9(params, COMPARTMENT_ID_PARAM$2, value);
+				return builder;
+			},
+			withAvailabilityDomain: (value) => {
+				pushParam$9(params, AVAILABILITY_DOMAIN_PARAM$1, value);
+				return builder;
+			},
+			withProhibitPublicIpOnVnic: (value) => {
+				pushParam$9(params, PROHIBIT_PUBLIC_IP_PARAM, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_OciSubnet.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildOciSubnetType()).withParameters(params).withProvider("OCI").withId(buildId$11(blueprint.id.toString())).withVersion(buildVersion$11(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const cidrBlock = blueprint.parameters.getOptionalFieldByName(CIDR_BLOCK_PARAM);
+		if (cidrBlock !== null) pushParam$9(params, CIDR_BLOCK_PARAM, String(cidrBlock));
+		const satisfiedBuilder = {
+			withCompartmentId: (value) => {
+				pushParam$9(params, COMPARTMENT_ID_PARAM$2, value);
+				return satisfiedBuilder;
+			},
+			withAvailabilityDomain: (value) => {
+				pushParam$9(params, AVAILABILITY_DOMAIN_PARAM$1, value);
+				return satisfiedBuilder;
+			},
+			withProhibitPublicIpOnVnic: (value) => {
+				pushParam$9(params, PROHIBIT_PUBLIC_IP_PARAM, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_OciSubnet.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withCidrBlock(config.cidrBlock).withCompartmentId(config.compartmentId);
+		if (config.description) b.withDescription(config.description);
+		if (config.availabilityDomain) b.withAvailabilityDomain(config.availabilityDomain);
+		if (config.prohibitPublicIpOnVnic !== void 0) b.withProhibitPublicIpOnVnic(config.prohibitPublicIpOnVnic);
+		return b.build();
+	};
+})(OciSubnet || (OciSubnet = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/oci_security_list.ts
+const OCI_SECURITY_LIST_TYPE_NAME = "OciSecurityList";
+const COMPARTMENT_ID_PARAM$1 = "compartmentId";
+function buildId$10(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$10(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildOciSecurityListType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(OCI_SECURITY_LIST_TYPE_NAME).build()).build();
+}
+function pushParam$8(params, key, value) {
+	params.push(key, value);
+}
+let OciSecurityList;
+(function(_OciSecurityList) {
+	const getBuilder = _OciSecurityList.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildOciSecurityListType()).withParameters(params).withProvider("OCI");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$10(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$10(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				pushParam$8(params, DESCRIPTION_PARAM, description);
+				return builder;
+			},
+			withIngressRules: (rules) => {
+				pushParam$8(params, INGRESS_RULES_PARAM, rules);
+				return builder;
+			},
+			withCompartmentId: (value) => {
+				pushParam$8(params, COMPARTMENT_ID_PARAM$1, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_OciSecurityList.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildOciSecurityListType()).withParameters(params).withProvider("OCI").withId(buildId$10(blueprint.id.toString())).withVersion(buildVersion$10(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		const description = blueprint.parameters.getOptionalFieldByName(DESCRIPTION_PARAM);
+		if (description !== null) {
+			inner.withDescription(String(description));
+			pushParam$8(params, DESCRIPTION_PARAM, String(description));
+		} else if (blueprint.description) inner.withDescription(blueprint.description);
+		const ingressRules = blueprint.parameters.getOptionalFieldByName(INGRESS_RULES_PARAM);
+		if (ingressRules !== null) pushParam$8(params, INGRESS_RULES_PARAM, ingressRules);
+		const satisfiedBuilder = {
+			withCompartmentId: (value) => {
+				pushParam$8(params, COMPARTMENT_ID_PARAM$1, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_OciSecurityList.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withCompartmentId(config.compartmentId);
+		if (config.description) b.withDescription(config.description);
+		if (config.ingressRules && config.ingressRules.length > 0) b.withIngressRules(config.ingressRules);
+		return b.build();
+	};
+})(OciSecurityList || (OciSecurityList = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/oci_instance.ts
+const OCI_INSTANCE_TYPE_NAME = "OciInstance";
+const COMPARTMENT_ID_PARAM = "compartmentId";
+const AVAILABILITY_DOMAIN_PARAM = "availabilityDomain";
+const SHAPE_PARAM = "shape";
+const IMAGE_ID_PARAM = "imageId";
+const OCPUS_PARAM = "ocpus";
+const MEMORY_IN_GBS_PARAM = "memoryInGbs";
+const SSH_PUBLIC_KEY_PARAM = "sshPublicKey";
+function buildId$9(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$9(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildOciInstanceType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(OCI_INSTANCE_TYPE_NAME).build()).build();
+}
+function pushParam$7(params, key, value) {
+	params.push(key, value);
+}
+let OciInstance;
+(function(_OciInstance) {
+	const getBuilder = _OciInstance.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildOciInstanceType()).withParameters(params).withProvider("OCI");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$9(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$9(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withCompartmentId: (value) => {
+				pushParam$7(params, COMPARTMENT_ID_PARAM, value);
+				return builder;
+			},
+			withAvailabilityDomain: (value) => {
+				pushParam$7(params, AVAILABILITY_DOMAIN_PARAM, value);
+				return builder;
+			},
+			withShape: (value) => {
+				pushParam$7(params, SHAPE_PARAM, value);
+				return builder;
+			},
+			withImageId: (value) => {
+				pushParam$7(params, IMAGE_ID_PARAM, value);
+				return builder;
+			},
+			withOcpus: (value) => {
+				pushParam$7(params, OCPUS_PARAM, value);
+				return builder;
+			},
+			withMemoryInGbs: (value) => {
+				pushParam$7(params, MEMORY_IN_GBS_PARAM, value);
+				return builder;
+			},
+			withSshPublicKey: (value) => {
+				pushParam$7(params, SSH_PUBLIC_KEY_PARAM, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_OciInstance.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildOciInstanceType()).withParameters(params).withProvider("OCI").withId(buildId$9(blueprint.id.toString())).withVersion(buildVersion$9(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const satisfiedBuilder = {
+			withCompartmentId: (value) => {
+				pushParam$7(params, COMPARTMENT_ID_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withAvailabilityDomain: (value) => {
+				pushParam$7(params, AVAILABILITY_DOMAIN_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withShape: (value) => {
+				pushParam$7(params, SHAPE_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withImageId: (value) => {
+				pushParam$7(params, IMAGE_ID_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withOcpus: (value) => {
+				pushParam$7(params, OCPUS_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withMemoryInGbs: (value) => {
+				pushParam$7(params, MEMORY_IN_GBS_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withSshPublicKey: (value) => {
+				pushParam$7(params, SSH_PUBLIC_KEY_PARAM, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_OciInstance.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withCompartmentId(config.compartmentId).withAvailabilityDomain(config.availabilityDomain).withShape(config.shape).withImageId(config.imageId);
+		if (config.description) b.withDescription(config.description);
+		if (config.ocpus !== void 0) b.withOcpus(config.ocpus);
+		if (config.memoryInGbs !== void 0) b.withMemoryInGbs(config.memoryInGbs);
+		if (config.sshPublicKey) b.withSshPublicKey(config.sshPublicKey);
+		return b.build();
+	};
+})(OciInstance || (OciInstance = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/hetzner_network.ts
+const HETZNER_NETWORK_TYPE_NAME = "HetznerNetwork";
+function buildId$8(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$8(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildHetznerNetworkType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(HETZNER_NETWORK_TYPE_NAME).build()).build();
+}
+function pushParam$6(params, key, value) {
+	params.push(key, value);
+}
+let HetznerNetwork;
+(function(_HetznerNetwork) {
+	const getBuilder = _HetznerNetwork.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildHetznerNetworkType()).withParameters(params).withProvider("Hetzner");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$8(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$8(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withCidrBlock: (value) => {
+				pushParam$6(params, CIDR_BLOCK_PARAM$1, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_HetznerNetwork.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildHetznerNetworkType()).withParameters(params).withProvider("Hetzner").withId(buildId$8(blueprint.id.toString())).withVersion(buildVersion$8(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const cidrBlock = blueprint.parameters.getOptionalFieldByName(CIDR_BLOCK_PARAM$1);
+		if (cidrBlock !== null) pushParam$6(params, CIDR_BLOCK_PARAM$1, String(cidrBlock));
+		return { build: () => inner.build() };
+	};
+	_HetznerNetwork.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withCidrBlock(config.cidrBlock);
+		if (config.description) b.withDescription(config.description);
+		return b.build();
+	};
+})(HetznerNetwork || (HetznerNetwork = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/hetzner_subnet.ts
+const HETZNER_SUBNET_TYPE_NAME = "HetznerSubnet";
+const NETWORK_ZONE_PARAM = "networkZone";
+const TYPE_PARAM = "type";
+function buildId$7(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$7(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildHetznerSubnetType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(HETZNER_SUBNET_TYPE_NAME).build()).build();
+}
+function pushParam$5(params, key, value) {
+	params.push(key, value);
+}
+let HetznerSubnet;
+(function(_HetznerSubnet) {
+	const getBuilder = _HetznerSubnet.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildHetznerSubnetType()).withParameters(params).withProvider("Hetzner");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$7(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$7(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withCidrBlock: (value) => {
+				pushParam$5(params, CIDR_BLOCK_PARAM, value);
+				return builder;
+			},
+			withNetworkZone: (value) => {
+				pushParam$5(params, NETWORK_ZONE_PARAM, value);
+				return builder;
+			},
+			withType: (value) => {
+				pushParam$5(params, TYPE_PARAM, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_HetznerSubnet.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildHetznerSubnetType()).withParameters(params).withProvider("Hetzner").withId(buildId$7(blueprint.id.toString())).withVersion(buildVersion$7(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const cidrBlock = blueprint.parameters.getOptionalFieldByName(CIDR_BLOCK_PARAM);
+		if (cidrBlock !== null) pushParam$5(params, CIDR_BLOCK_PARAM, String(cidrBlock));
+		const satisfiedBuilder = {
+			withNetworkZone: (value) => {
+				pushParam$5(params, NETWORK_ZONE_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withType: (value) => {
+				pushParam$5(params, TYPE_PARAM, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_HetznerSubnet.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withCidrBlock(config.cidrBlock).withNetworkZone(config.networkZone);
+		if (config.description) b.withDescription(config.description);
+		if (config.type) b.withType(config.type);
+		return b.build();
+	};
+})(HetznerSubnet || (HetznerSubnet = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/hetzner_firewall.ts
+const HETZNER_FIREWALL_TYPE_NAME = "HetznerFirewall";
+function buildId$6(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$6(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildHetznerFirewallType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(HETZNER_FIREWALL_TYPE_NAME).build()).build();
+}
+function pushParam$4(params, key, value) {
+	params.push(key, value);
+}
+let HetznerFirewall;
+(function(_HetznerFirewall) {
+	const getBuilder = _HetznerFirewall.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildHetznerFirewallType()).withParameters(params).withProvider("Hetzner");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$6(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$6(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				pushParam$4(params, DESCRIPTION_PARAM, description);
+				return builder;
+			},
+			withIngressRules: (rules) => {
+				pushParam$4(params, INGRESS_RULES_PARAM, rules);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_HetznerFirewall.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildHetznerFirewallType()).withParameters(params).withProvider("Hetzner").withId(buildId$6(blueprint.id.toString())).withVersion(buildVersion$6(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		const description = blueprint.parameters.getOptionalFieldByName(DESCRIPTION_PARAM);
+		if (description !== null) {
+			inner.withDescription(String(description));
+			pushParam$4(params, DESCRIPTION_PARAM, String(description));
+		} else if (blueprint.description) inner.withDescription(blueprint.description);
+		const ingressRules = blueprint.parameters.getOptionalFieldByName(INGRESS_RULES_PARAM);
+		if (ingressRules !== null) pushParam$4(params, INGRESS_RULES_PARAM, ingressRules);
+		return { build: () => inner.build() };
+	};
+	_HetznerFirewall.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName);
+		if (config.description) b.withDescription(config.description);
+		if (config.ingressRules && config.ingressRules.length > 0) b.withIngressRules(config.ingressRules);
+		return b.build();
+	};
+})(HetznerFirewall || (HetznerFirewall = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/hetzner_server.ts
+const HETZNER_SERVER_TYPE_NAME = "HetznerServer";
+const SERVER_TYPE_PARAM = "serverType";
+const LOCATION_PARAM = "location";
+const IMAGE_PARAM = "image";
+const SSH_KEYS_PARAM = "sshKeys";
+const USER_DATA_PARAM = "userData";
+function buildId$5(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$5(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildHetznerServerType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.IaaS).withName(PascalCaseString$1.getBuilder().withValue(HETZNER_SERVER_TYPE_NAME).build()).build();
+}
+function pushParam$3(params, key, value) {
+	params.push(key, value);
+}
+let HetznerServer;
+(function(_HetznerServer) {
+	const getBuilder = _HetznerServer.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildHetznerServerType()).withParameters(params).withProvider("Hetzner");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$5(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$5(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withServerType: (value) => {
+				pushParam$3(params, SERVER_TYPE_PARAM, value);
+				return builder;
+			},
+			withLocation: (value) => {
+				pushParam$3(params, LOCATION_PARAM, value);
+				return builder;
+			},
+			withImage: (value) => {
+				pushParam$3(params, IMAGE_PARAM, value);
+				return builder;
+			},
+			withSshKeys: (value) => {
+				pushParam$3(params, SSH_KEYS_PARAM, value);
+				return builder;
+			},
+			withUserData: (value) => {
+				pushParam$3(params, USER_DATA_PARAM, value);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_HetznerServer.satisfy = (blueprint) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildHetznerServerType()).withParameters(params).withProvider("Hetzner").withId(buildId$5(blueprint.id.toString())).withVersion(buildVersion$5(blueprint.version.major, blueprint.version.minor, blueprint.version.patch)).withDisplayName(blueprint.displayName).withDependencies(blueprint.dependencies).withLinks(blueprint.links);
+		if (blueprint.description) inner.withDescription(blueprint.description);
+		const satisfiedBuilder = {
+			withServerType: (value) => {
+				pushParam$3(params, SERVER_TYPE_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withLocation: (value) => {
+				pushParam$3(params, LOCATION_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withImage: (value) => {
+				pushParam$3(params, IMAGE_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withSshKeys: (value) => {
+				pushParam$3(params, SSH_KEYS_PARAM, value);
+				return satisfiedBuilder;
+			},
+			withUserData: (value) => {
+				pushParam$3(params, USER_DATA_PARAM, value);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_HetznerServer.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withServerType(config.serverType).withLocation(config.location).withImage(config.image);
+		if (config.description) b.withDescription(config.description);
+		if (config.sshKeys && config.sshKeys.length > 0) b.withSshKeys(config.sshKeys);
+		if (config.userData) b.withUserData(config.userData);
+		return b.build();
+	};
+})(HetznerServer || (HetznerServer = {}));
+
+//#endregion
+//#region src/fractal/component/network_and_compute/paas/container_platform.ts
+const CONTAINER_PLATFORM_TYPE_NAME = "ContainerPlatform";
+function buildId$4(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$4(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildContainerPlatformType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.PaaS).withName(PascalCaseString$1.getBuilder().withValue(CONTAINER_PLATFORM_TYPE_NAME).build()).build();
+}
+function makeContainerPlatformNode(platform, workloadNodes) {
+	const platformDep = { id: platform.id };
+	return {
+		platform,
+		workloads: workloadNodes.map((w) => ({
+			...w,
+			component: {
+				...w.component,
+				dependencies: [...w.component.dependencies, platformDep]
+			}
+		})),
+		withWorkloads: (newWorkloads) => makeContainerPlatformNode(platform, newWorkloads)
+	};
+}
+let ContainerPlatform;
+(function(_ContainerPlatform) {
+	const getBuilder = _ContainerPlatform.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getBlueprintComponentBuilder().withType(buildContainerPlatformType()).withParameters(params);
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$4(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$4(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_ContainerPlatform.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName);
+		if (config.description) b.withDescription(config.description);
+		return makeContainerPlatformNode(b.build(), []);
+	};
+})(ContainerPlatform || (ContainerPlatform = {}));
+
+//#endregion
+//#region src/fractal/component/custom_workloads/caas/workload.ts
+const WORKLOAD_TYPE_NAME = "Workload";
+const CONTAINER_IMAGE_PARAM = "containerImage";
+const CONTAINER_PORT_PARAM = "containerPort";
+const CONTAINER_NAME_PARAM = "containerName";
+const CPU_PARAM = "cpu";
+const MEMORY_PARAM = "memory";
+const DESIRED_COUNT_PARAM = "desiredCount";
+function buildId$3(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$3(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildWorkloadType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.CustomWorkloads).withServiceDeliveryModel(ServiceDeliveryModel$1.CaaS).withName(PascalCaseString$1.getBuilder().withValue(WORKLOAD_TYPE_NAME).build()).build();
+}
+function pushParam$2(params, key, value) {
+	params.push(key, value);
+}
+function buildLinkParams(fromPort, toPort, protocol) {
+	const p = getParametersInstance();
+	p.push("fromPort", fromPort);
+	if (toPort !== void 0) p.push("toPort", toPort);
+	if (protocol) p.push("protocol", protocol);
+	return p;
+}
+function makeWorkloadNode(component) {
+	return {
+		component,
+		components: [component],
+		withLinks: (links) => {
+			const portLinks = links.map((l) => getLinkBuilder().withId(l.target.component.id).withType(buildWorkloadType()).withParameters(buildLinkParams(l.fromPort, l.toPort, l.protocol)).build());
+			return makeWorkloadNode({
+				...component,
+				links: [...component.links, ...portLinks]
+			});
+		},
+		withSecurityGroups: (sgs) => {
+			const sgLinks = sgs.map((sg) => getLinkBuilder().withId(sg.id).withType(sg.type).withParameters(getParametersInstance()).build());
+			return makeWorkloadNode({
+				...component,
+				links: [...component.links, ...sgLinks]
+			});
+		}
+	};
+}
+let Workload;
+(function(_Workload) {
+	const getBuilder = _Workload.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getBlueprintComponentBuilder().withType(buildWorkloadType()).withParameters(params);
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$3(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$3(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withContainerImage: (image) => {
+				pushParam$2(params, CONTAINER_IMAGE_PARAM, image);
+				return builder;
+			},
+			withContainerPort: (port) => {
+				pushParam$2(params, CONTAINER_PORT_PARAM, port);
+				return builder;
+			},
+			withContainerName: (name) => {
+				pushParam$2(params, CONTAINER_NAME_PARAM, name);
+				return builder;
+			},
+			withCpu: (cpu) => {
+				pushParam$2(params, CPU_PARAM, cpu);
+				return builder;
+			},
+			withMemory: (memory) => {
+				pushParam$2(params, MEMORY_PARAM, memory);
+				return builder;
+			},
+			withDesiredCount: (count) => {
+				pushParam$2(params, DESIRED_COUNT_PARAM, count);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_Workload.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withContainerImage(config.containerImage);
+		if (config.description) b.withDescription(config.description);
+		if (config.containerPort !== void 0) b.withContainerPort(config.containerPort);
+		if (config.containerName) b.withContainerName(config.containerName);
+		if (config.cpu) b.withCpu(config.cpu);
+		if (config.memory) b.withMemory(config.memory);
+		if (config.desiredCount !== void 0) b.withDesiredCount(config.desiredCount);
+		return makeWorkloadNode(b.build());
+	};
+})(Workload || (Workload = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/paas/ecs_cluster.ts
+const ECS_CLUSTER_TYPE_NAME = "ECS";
+function buildId$2(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$2(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildAwsEcsClusterType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.PaaS).withName(PascalCaseString$1.getBuilder().withValue(ECS_CLUSTER_TYPE_NAME).build()).build();
+}
+let AwsEcsCluster;
+(function(_AwsEcsCluster) {
+	const getBuilder = _AwsEcsCluster.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAwsEcsClusterType()).withParameters(params).withProvider("AWS");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$2(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$2(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_AwsEcsCluster.satisfy = (platform) => {
+		const inner = getLiveSystemComponentBuilder().withType(buildAwsEcsClusterType()).withParameters(getParametersInstance()).withProvider("AWS").withId(buildId$2(platform.id.toString())).withVersion(buildVersion$2(platform.version.major, platform.version.minor, platform.version.patch)).withDisplayName(platform.displayName);
+		if (platform.description) inner.withDescription(platform.description);
+		return { build: () => inner.build() };
+	};
+	_AwsEcsCluster.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName);
+		if (config.description) b.withDescription(config.description);
+		return b.build();
+	};
+})(AwsEcsCluster || (AwsEcsCluster = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/paas/ecs_task_definition.ts
+const ECS_TASK_DEF_TYPE_NAME = "ECSTaskDefinition";
+const NETWORK_MODE_PARAM = "networkMode";
+const EXECUTION_ROLE_ARN_PARAM = "executionRoleArn";
+const TASK_ROLE_ARN_PARAM = "taskRoleArn";
+function buildId$1(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion$1(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildAwsEcsTaskDefType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.PaaS).withName(PascalCaseString$1.getBuilder().withValue(ECS_TASK_DEF_TYPE_NAME).build()).build();
+}
+function pushParam$1(params, key, value) {
+	params.push(key, value);
+}
+let AwsEcsTaskDefinition;
+(function(_AwsEcsTaskDefinition) {
+	const getBuilder = _AwsEcsTaskDefinition.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAwsEcsTaskDefType()).withParameters(params).withProvider("AWS");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId$1(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion$1(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withContainerImage: (image) => {
+				pushParam$1(params, CONTAINER_IMAGE_PARAM, image);
+				return builder;
+			},
+			withContainerPort: (port) => {
+				pushParam$1(params, CONTAINER_PORT_PARAM, port);
+				return builder;
+			},
+			withContainerName: (name) => {
+				pushParam$1(params, CONTAINER_NAME_PARAM, name);
+				return builder;
+			},
+			withCpu: (cpu) => {
+				pushParam$1(params, CPU_PARAM, cpu);
+				return builder;
+			},
+			withMemory: (memory) => {
+				pushParam$1(params, MEMORY_PARAM, memory);
+				return builder;
+			},
+			withNetworkMode: (mode) => {
+				pushParam$1(params, NETWORK_MODE_PARAM, mode);
+				return builder;
+			},
+			withExecutionRoleArn: (arn) => {
+				pushParam$1(params, EXECUTION_ROLE_ARN_PARAM, arn);
+				return builder;
+			},
+			withTaskRoleArn: (arn) => {
+				pushParam$1(params, TASK_ROLE_ARN_PARAM, arn);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_AwsEcsTaskDefinition.satisfy = (workload) => {
+		const params = getParametersInstance();
+		const taskId = `${workload.id.toString()}-task`;
+		const inner = getLiveSystemComponentBuilder().withType(buildAwsEcsTaskDefType()).withParameters(params).withProvider("AWS").withId(buildId$1(taskId)).withVersion(buildVersion$1(workload.version.major, workload.version.minor, workload.version.patch)).withDisplayName(workload.displayName);
+		if (workload.description) inner.withDescription(workload.description);
+		for (const key of [
+			CONTAINER_IMAGE_PARAM,
+			CONTAINER_PORT_PARAM,
+			CONTAINER_NAME_PARAM,
+			CPU_PARAM,
+			MEMORY_PARAM
+		]) {
+			const v = workload.parameters.getOptionalFieldByName(key);
+			if (v !== null) pushParam$1(params, key, v);
+		}
+		const satisfiedBuilder = {
+			withNetworkMode: (mode) => {
+				pushParam$1(params, NETWORK_MODE_PARAM, mode);
+				return satisfiedBuilder;
+			},
+			withExecutionRoleArn: (arn) => {
+				pushParam$1(params, EXECUTION_ROLE_ARN_PARAM, arn);
+				return satisfiedBuilder;
+			},
+			withTaskRoleArn: (arn) => {
+				pushParam$1(params, TASK_ROLE_ARN_PARAM, arn);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_AwsEcsTaskDefinition.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName).withContainerImage(config.containerImage);
+		if (config.description) b.withDescription(config.description);
+		if (config.containerPort !== void 0) b.withContainerPort(config.containerPort);
+		if (config.containerName) b.withContainerName(config.containerName);
+		if (config.cpu) b.withCpu(config.cpu);
+		if (config.memory) b.withMemory(config.memory);
+		if (config.networkMode) b.withNetworkMode(config.networkMode);
+		if (config.executionRoleArn) b.withExecutionRoleArn(config.executionRoleArn);
+		if (config.taskRoleArn) b.withTaskRoleArn(config.taskRoleArn);
+		return b.build();
+	};
+})(AwsEcsTaskDefinition || (AwsEcsTaskDefinition = {}));
+
+//#endregion
+//#region src/live_system/component/network_and_compute/paas/ecs_service.ts
+const ECS_SERVICE_TYPE_NAME = "ECSService";
+const LAUNCH_TYPE_PARAM = "launchType";
+const ASSIGN_PUBLIC_IP_PARAM = "assignPublicIp";
+function buildId(id) {
+	return getComponentIdBuilder().withValue(KebabCaseString$1.getBuilder().withValue(id).build()).build();
+}
+function buildVersion(major, minor, patch) {
+	return getVersionBuilder().withMajor(major).withMinor(minor).withPatch(patch).build();
+}
+function buildAwsEcsServiceType() {
+	return getBlueprintComponentTypeBuilder().withInfrastructureDomain(InfrastructureDomain$1.NetworkAndCompute).withServiceDeliveryModel(ServiceDeliveryModel$1.PaaS).withName(PascalCaseString$1.getBuilder().withValue(ECS_SERVICE_TYPE_NAME).build()).build();
+}
+function pushParam(params, key, value) {
+	params.push(key, value);
+}
+let AwsEcsService;
+(function(_AwsEcsService) {
+	const getBuilder = _AwsEcsService.getBuilder = () => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAwsEcsServiceType()).withParameters(params).withProvider("AWS");
+		const builder = {
+			withId: (id) => {
+				inner.withId(buildId(id));
+				return builder;
+			},
+			withVersion: (major, minor, patch) => {
+				inner.withVersion(buildVersion(major, minor, patch));
+				return builder;
+			},
+			withDisplayName: (displayName) => {
+				inner.withDisplayName(displayName);
+				return builder;
+			},
+			withDescription: (description) => {
+				inner.withDescription(description);
+				return builder;
+			},
+			withDesiredCount: (count) => {
+				pushParam(params, DESIRED_COUNT_PARAM, count);
+				return builder;
+			},
+			withLaunchType: (type) => {
+				pushParam(params, LAUNCH_TYPE_PARAM, type);
+				return builder;
+			},
+			withAssignPublicIp: (assign) => {
+				pushParam(params, ASSIGN_PUBLIC_IP_PARAM, assign);
+				return builder;
+			},
+			build: () => inner.build()
+		};
+		return builder;
+	};
+	_AwsEcsService.satisfy = (workload) => {
+		const params = getParametersInstance();
+		const inner = getLiveSystemComponentBuilder().withType(buildAwsEcsServiceType()).withParameters(params).withProvider("AWS").withId(buildId(workload.id.toString())).withVersion(buildVersion(workload.version.major, workload.version.minor, workload.version.patch)).withDisplayName(workload.displayName).withDependencies(workload.dependencies).withLinks(workload.links);
+		if (workload.description) inner.withDescription(workload.description);
+		const desiredCount = workload.parameters.getOptionalFieldByName(DESIRED_COUNT_PARAM);
+		if (desiredCount !== null) pushParam(params, DESIRED_COUNT_PARAM, desiredCount);
+		const satisfiedBuilder = {
+			withLaunchType: (type) => {
+				pushParam(params, LAUNCH_TYPE_PARAM, type);
+				return satisfiedBuilder;
+			},
+			withAssignPublicIp: (assign) => {
+				pushParam(params, ASSIGN_PUBLIC_IP_PARAM, assign);
+				return satisfiedBuilder;
+			},
+			build: () => inner.build()
+		};
+		return satisfiedBuilder;
+	};
+	_AwsEcsService.create = (config) => {
+		const b = getBuilder().withId(config.id).withVersion(config.version.major, config.version.minor, config.version.patch).withDisplayName(config.displayName);
+		if (config.description) b.withDescription(config.description);
+		if (config.desiredCount !== void 0) b.withDesiredCount(config.desiredCount);
+		if (config.launchType) b.withLaunchType(config.launchType);
+		if (config.assignPublicIp !== void 0) b.withAssignPublicIp(config.assignPublicIp);
+		return b.build();
+	};
+})(AwsEcsService || (AwsEcsService = {}));
+
 //#endregion
 //#region src/index.ts
 const BoundedContext = BoundedContext$1;
@@ -2026,4 +4536,4 @@ const Environment = Environment$1;
 const LiveSystem = LiveSystem$1;
 
 //#endregion
-export { BoundedContext, Environment, Fractal, InfrastructureDomain, KebabCaseString, LiveSystem, OwnerId, OwnerType, PascalCaseString, ServiceAccountCredentials, ServiceAccountId, ServiceDeliveryModel, Version };
+export { AwsEcsCluster, AwsEcsService, AwsEcsTaskDefinition, AwsSecurityGroup, AwsSubnet, AwsVpc, AzureNsg, AzureSubnet, AzureVm, AzureVnet, BoundedContext, ContainerPlatform, Ec2Instance, Environment, Fractal, GcpFirewall, GcpSubnet, GcpVm, GcpVpc, HetznerFirewall, HetznerNetwork, HetznerServer, HetznerSubnet, InfrastructureDomain, KebabCaseString, LiveSystem, OciInstance, OciSecurityList, OciSubnet, OciVcn, OwnerId, OwnerType, PascalCaseString, SecurityGroup, ServiceAccountCredentials, ServiceAccountId, ServiceDeliveryModel, Subnet, Version, VirtualMachine, VirtualNetwork, Workload };