@fractal_cloud/sdk 0.1.2 → 1.0.0

package/dist/index.mjs

@@ -12,7 +12,12 @@ import superagent from "superagent";
 *
 * @type {KebabCaseString}
 */
-const DEFAULT_KEBAB_CASE_STRING = { kebabValue: "" };
+const DEFAULT_KEBAB_CASE_STRING = {
+	_type: "kebab",
+	value: "",
+	equals: () => false,
+	toString: () => ""
+};
 /**
 * Validates whether a given string follows the kebab-case format.
 *
@@ -26,7 +31,7 @@ const DEFAULT_KEBAB_CASE_STRING = { kebabValue: "" };
 * @returns {string[]} - An empty array if the string is valid, otherwise an array containing an error message.
 */
 const isValidKebabCaseString = (value) => {
-	if (!/^[a-z][a-z0-9]*(-[a-z][a-z0-9]*)*$/.test(value)) return ["Value must be in kebab-case"];
+	if (!/^[a-z][a-z0-9]*(-[a-z][a-z0-9]*)*$/.test(value)) return [` Value '${value}' must be in kebab-case`];
 	return [];
 };
 /**
@@ -43,17 +48,21 @@ const getKebabCaseStringBuilder = () => {
 	const internalState = { ...DEFAULT_KEBAB_CASE_STRING };
 	const builder = {
 		withValue: (value) => {
-			internalState.kebabValue = value;
+			internalState.value = value;
 			return builder;
 		},
 		reset: () => {
-			internalState.kebabValue = DEFAULT_KEBAB_CASE_STRING.kebabValue;
+			internalState.value = DEFAULT_KEBAB_CASE_STRING.value;
 			return builder;
 		},
 		build: () => {
-			const validationErrors = isValidKebabCaseString(internalState.kebabValue);
+			const validationErrors = isValidKebabCaseString(internalState.value);
 			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
-			return { ...internalState };
+			return {
+				...internalState,
+				equals: (other) => internalState.value === other.value,
+				toString: () => internalState.value
+			};
 		}
 	};
 	return builder;
@@ -65,8 +74,8 @@ let KebabCaseString$1;
 
 //#endregion
 //#region src/values/version.ts
-const equals$2 = (a, b) => a.major === b.major && a.minor === b.minor && a.patch === b.patch;
-const toString$1 = (version) => `v${version.major}.${version.minor}.${version.patch}`;
+const equals$4 = (a, b) => a.major === b.major && a.minor === b.minor && a.patch === b.patch;
+const toString$2 = (version) => `v${version.major}.${version.minor}.${version.patch}`;
 /**
 * Represents the default version for an application or library.
 *
@@ -77,7 +86,7 @@ const DEFAULT_VERSION = {
 	major: 0,
 	minor: 0,
 	patch: 0,
-	equals: (other) => equals$2(DEFAULT_VERSION, other)
+	equals: (other) => equals$4(DEFAULT_VERSION, other)
 };
 /**
 * Validates if the provided version object is properly initialized or equivalent to the default version.
@@ -87,7 +96,7 @@ const DEFAULT_VERSION = {
 *                     an array containing one error message. Otherwise, it returns an empty array.
 */
 const isValidVersion = (version) => {
-	if (equals$2(version, DEFAULT_VERSION)) return ["Version must be initialized"];
+	if (equals$4(version, DEFAULT_VERSION)) return [" Version must be initialized"];
 	return [];
 };
 /**
@@ -144,8 +153,8 @@ const getVersionBuilder = () => {
 			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
 			const builtVersion = {
 				...internalState,
-				equals: (other) => equals$2(builtVersion, other),
-				toString: () => toString$1(builtVersion)
+				equals: (other) => equals$4(builtVersion, other),
+				toString: () => toString$2(builtVersion)
 			};
 			return builtVersion;
 		}
@@ -179,7 +188,7 @@ let OwnerType$1 = /* @__PURE__ */ function(OwnerType) {
 //#endregion
 //#region src/values/guid.ts
 const isValidUuid = (value) => {
-	if (!/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(value)) return [`Value '${value}' must be a valid uuid`];
+	if (!/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(value)) return [` Value '${value}' must be a valid uuid`];
 	return [];
 };
 
@@ -191,7 +200,11 @@ const isValidUuid = (value) => {
 * This variable is declared as a constant to prevent modification
 * and is designed to not pass validation checks.
 */
-const DEFAULT_OWNER_ID = { ownerIdValue: "" };
+const DEFAULT_OWNER_ID = {
+	_type: "ownerId",
+	value: "",
+	toString: () => ""
+};
 /**
 * Validates whether the given string value is a valid UUID.
 *
@@ -203,8 +216,11 @@ const DEFAULT_OWNER_ID = { ownerIdValue: "" };
 * @returns {string[]} An array containing error messages if invalid, or an empty array if valid.
 */
 const isValidOwnerId = (value) => {
-	if (!value || !value.ownerIdValue) return ["Value must be a non-empty string"];
-	return isValidUuid(value.ownerIdValue);
+	if (!value || !value.value) return ["[Owner Id] Value must be a non-empty string"];
+	return addContextToErrors$8(value, isValidUuid(value.value));
+};
+const addContextToErrors$8 = (value, errors) => {
+	return errors.map((error) => `[Owner Id: ${value.toString()}]${error}`);
 };
 /**
 * Creates a builder for constructing a OwnerId object. The builder enforces uuid case formatting and ensures
@@ -220,17 +236,20 @@ const getOwnerIdBuilder = () => {
 	const internalState = { ...DEFAULT_OWNER_ID };
 	const builder = {
 		withValue: (value) => {
-			internalState.ownerIdValue = value;
+			internalState.value = value;
 			return builder;
 		},
 		reset: () => {
-			internalState.ownerIdValue = DEFAULT_OWNER_ID.ownerIdValue;
+			internalState.value = DEFAULT_OWNER_ID.value;
 			return builder;
 		},
 		build: () => {
 			const validationErrors = isValidOwnerId(internalState);
 			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
-			return { ...internalState };
+			return {
+				...internalState,
+				toString: () => internalState.value
+			};
 		}
 	};
 	return builder;
@@ -242,17 +261,18 @@ let OwnerId$1;
 
 //#endregion
 //#region src/bounded_context/id.ts
-const equals$1 = (a, b) => a.ownerType === b.ownerType && a.ownerId.ownerIdValue === b.ownerId.ownerIdValue && a.name.kebabValue === b.name.kebabValue;
+const equals$3 = (a, b) => a.ownerType === b.ownerType && a.ownerId.value === b.ownerId.value && a.name.value === b.name.value;
 /**
 * A default value for the bounded context identifier used in the system.
 * It contains values that will not pass validation checks.
 */
 const DEFAULT_BOUNDED_CONTEXT_ID = {
+	_type: "bounded_context",
 	ownerType: OwnerType$1.Personal,
 	ownerId: DEFAULT_OWNER_ID,
 	name: DEFAULT_KEBAB_CASE_STRING,
-	equals: (other) => equals$1(DEFAULT_BOUNDED_CONTEXT_ID, other),
-	toString: () => boundedContextIdToString(DEFAULT_BOUNDED_CONTEXT_ID)
+	equals: () => false,
+	toString: () => ""
 };
 /**
 * Determines whether the given value is a valid Id.
@@ -267,11 +287,14 @@ const DEFAULT_BOUNDED_CONTEXT_ID = {
 *   the `isValidKebabCaseString` function.
 */
 const isValidBoundedContextId = (value) => {
-	const ownerIdErrors = isValidOwnerId(value.ownerId);
-	const nameErrors = isValidKebabCaseString(value.name.kebabValue);
-	return [...ownerIdErrors.map((x) => `[Bounded Context Id: ${boundedContextIdToString(value)}] Owner Id error: ${x}`), ...nameErrors.map((x) => `[Bounded Context Id: ${boundedContextIdToString(value)}] Name error: ${x}`)];
+	const ownerIdErrors = addContextToErrors$7(value, isValidOwnerId(value.ownerId));
+	const nameErrors = addContextToErrors$7(value, isValidKebabCaseString(value.name.value));
+	return [...ownerIdErrors, ...nameErrors];
 };
-const boundedContextIdToString = (id) => `${id.ownerType.toString()}/${id.ownerId.ownerIdValue}/${id.name.kebabValue}`;
+const addContextToErrors$7 = (bcId, errors) => {
+	return errors.map((error) => `[Bounded Context Id: ${bcId.toString()}]${error}`);
+};
+const boundedContextIdToString = (id) => `${id.ownerType.toString()}/${id.ownerId.value}/${id.name.value}`;
 /**
 * Creates and returns a builder for constructing a `Id` object.
 *
@@ -309,7 +332,7 @@ const getBoundedContextIdBuilder = () => {
 			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
 			const builtId = {
 				...internalState,
-				equals: (other) => equals$1(builtId, other),
+				equals: (other) => equals$3(builtId, other),
 				toString: () => boundedContextIdToString(builtId)
 			};
 			return builtId;
@@ -320,7 +343,8 @@ const getBoundedContextIdBuilder = () => {
 
 //#endregion
 //#region src/fractal/id.ts
-const toString = (id) => `${id.boundedContextId.toString()}/${id.name.kebabValue}:${id.version.toString()}`;
+const equals$2 = (a, b) => a.boundedContextId.equals(b.boundedContextId) && a.name.equals(b.name) && a.version.equals(b.version);
+const toString$1 = (id) => `${id.boundedContextId.toString()}/${id.name.toString()}:${id.version.toString()}`;
 /**
 * Validates a given Fractal ID and returns a list of error messages if any validation fails.
 * The validation process includes checking the bounded context ID, the name, and the version of the Fractal ID.
@@ -329,15 +353,18 @@ const toString = (id) => `${id.boundedContextId.toString()}/${id.name.kebabValue
 * @returns {string[]} An array of error messages. Each error message indicates the specific issue with the bounded context ID, name, or version of the Fractal ID.
 */
 const isValidFractalId = (id) => {
-	const boundedContextIdErrors = isValidBoundedContextId(id.boundedContextId);
-	const nameErrors = isValidKebabCaseString(id.name.kebabValue);
-	const versionErrors = isValidVersion(id.version);
+	const boundedContextIdErrors = addContextToErrors$6(id, isValidBoundedContextId(id.boundedContextId));
+	const nameErrors = addContextToErrors$6(id, isValidKebabCaseString(id.name.value));
+	const versionErrors = addContextToErrors$6(id, isValidVersion(id.version));
 	return [
-		...boundedContextIdErrors.map((x) => `[Fractal Id: ${id.toString()}] Bounded Context Id error: ${x}`),
-		...nameErrors.map((x) => `[Fractal Id: ${id.toString()}] Name errors: ${x}`),
-		...versionErrors.map((x) => `[Fractal Id: ${id.toString()}] Version error: ${x}`)
+		...boundedContextIdErrors,
+		...nameErrors,
+		...versionErrors
 	];
 };
+const addContextToErrors$6 = (value, errors) => {
+	return errors.map((error) => `[Fractal Id: ${toString$1(value)}]${error}`);
+};
 /**
 * Represents the default identifier for a fractal instance.
 *
@@ -357,7 +384,9 @@ const isValidFractalId = (id) => {
 const DEFAULT_FRACTAL_ID = {
 	boundedContextId: DEFAULT_BOUNDED_CONTEXT_ID,
 	name: DEFAULT_KEBAB_CASE_STRING,
-	version: DEFAULT_VERSION
+	version: DEFAULT_VERSION,
+	equals: () => false,
+	toString: () => ""
 };
 /**
 * Provides a builder for constructing a `FractalId` object.
@@ -400,7 +429,8 @@ const getFractalIdBuilder = () => {
 			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
 			const builtId = {
 				...internalState,
-				toString: () => toString(builtId)
+				equals: (other) => equals$2(builtId, other),
+				toString: () => toString$1(builtId)
 			};
 			return builtId;
 		}
@@ -443,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-Z]*$/.test(value)) return [` Value '${value}' must be in PascalCase`];
 	return [];
 };
 /**
@@ -452,7 +482,12 @@ const isValidPascalCaseString = (value) => {
 * This variable is declared as a constant to prevent modification
 * and is designed to not pass validation checks.
 */
-const DEFAULT_PASCAL_CASE_STRING = { pascalValue: "" };
+const DEFAULT_PASCAL_CASE_STRING = {
+	_type: "pascal",
+	value: "",
+	equals: () => false,
+	toString: () => ""
+};
 /**
 * Creates a builder for constructing a PascalCaseString object. The builder enforces Pascal case formatting and ensures
 * a valid string is set before building. Once built, the PascalCaseString object becomes immutable.
@@ -467,17 +502,21 @@ const getPascalCaseStringBuilder = () => {
 	const internalState = { ...DEFAULT_PASCAL_CASE_STRING };
 	const builder = {
 		withValue: (value) => {
-			internalState.pascalValue = value;
+			internalState.value = value;
 			return builder;
 		},
 		reset: () => {
-			internalState.pascalValue = DEFAULT_PASCAL_CASE_STRING.pascalValue;
+			internalState.value = DEFAULT_PASCAL_CASE_STRING.value;
 			return builder;
 		},
 		build: () => {
-			const validationErrors = isValidPascalCaseString(internalState.pascalValue);
+			const validationErrors = isValidPascalCaseString(internalState.value);
 			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
-			return { ...internalState };
+			return {
+				...internalState,
+				equals: (other) => internalState.value === other.value,
+				toString: () => internalState.value
+			};
 		}
 	};
 	return builder;
@@ -537,8 +576,8 @@ const DEFAULT_COMPONENT_TYPE = {
 * @returns {string[]} An array of error messages if validation fails; an empty array if the name is valid.
 */
 const isValidComponentType = (type) => {
-	const nameError = isValidPascalCaseString(type.name.pascalValue);
-	if (nameError.length > 0) return nameError.map((x) => `[Component Type: ${type.name.pascalValue}] Name error: ${x}`);
+	const nameError = isValidPascalCaseString(type.name.value);
+	if (nameError.length > 0) return nameError.map((x) => `[Component Type: ${type.name.value}][Name]${x}`);
 	return [];
 };
 /**
@@ -651,7 +690,10 @@ const getBlueprintComponentTypeBuilder = () => {
 		build: () => {
 			const validationErrors = isValidBlueprintComponentType(internalState);
 			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
-			return { ...internalState };
+			return {
+				...internalState,
+				toString: () => `${internalState.domain}.${internalState.serviceDeliveryModel}.${internalState.name}`
+			};
 		}
 	};
 	return builder;
@@ -693,16 +735,17 @@ const getParametersInstance = () => {
 * @returns {boolean} - Returns true if the identifier is in a valid kebab-case format, false otherwise.
 */
 const isValidId = (id) => {
-	return isValidKebabCaseString(id.value.kebabValue).map((x) => `[Component Id: ${id.value.kebabValue}] Id error: ${x}`);
+	return isValidKebabCaseString(id.value.toString()).map((x) => `[Component Id: ${id.value.toString()}]${x}`);
 };
-const equals = (a, b) => a.value === b.value;
+const equals$1 = (a, b) => a.value === b.value;
 /**
 * Represents the default identifier used in the application.
 * It is initialized with a value that will not pass validation.
 */
 const DEFAULT_COMPONENT_ID = {
 	value: DEFAULT_KEBAB_CASE_STRING,
-	equals: (other) => equals(DEFAULT_COMPONENT_ID, other)
+	equals: (other) => equals$1(DEFAULT_COMPONENT_ID, other),
+	toString: () => ""
 };
 /**
 * Creates and returns a builder for constructing a `ComponentId` object.
@@ -730,7 +773,8 @@ const getComponentIdBuilder = () => {
 			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
 			const builtId = {
 				...internalState,
-				equals: (other) => equals(builtId, other)
+				equals: (other) => equals$1(builtId, other),
+				toString: () => builtId.value.toString()
 			};
 			return builtId;
 		}
@@ -856,18 +900,21 @@ const DEFAULT_COMPONENT = {
 * @returns {string[]} An array of error messages, each describing a specific validation failure. If no errors are found, the array will be empty.
 */
 const isValidComponent = (component) => {
-	const idErrors = isValidId(component.id);
-	const typeErrors = isValidComponentType(component.type);
-	const versionErrors = isValidVersion(component.version);
-	const displayNameErrors = isNonEmptyString(component.displayName) ? [] : ["Display name must be a non-empty string"];
+	const idErrors = addContextToErrors$5(component.id, isValidId(component.id));
+	const typeErrors = addContextToErrors$5(component.id, isValidComponentType(component.type));
+	const versionErrors = addContextToErrors$5(component.id, isValidVersion(component.version));
+	const displayNameErrors = addContextToErrors$5(component.id, isNonEmptyString(component.displayName) ? [] : ["Display name must be a non-empty string"]);
 	return [
-		...idErrors.map((x) => `[Component: ${component.id.value}] Id error: ${x}`),
-		...typeErrors.map((x) => `[Component: ${component.id.value}] Type error: ${x}`),
-		...versionErrors.map((x) => `[Component: ${component.id.value}] Version error: ${x}`),
-		...typeErrors.map((x) => `[Component: ${component.id.value}] Type error: ${x}`),
-		...displayNameErrors.map((x) => `[Component: ${component.id.value}] Display Name error: ${x}`)
+		...idErrors,
+		...typeErrors,
+		...versionErrors,
+		...typeErrors,
+		...displayNameErrors
 	];
 };
+const addContextToErrors$5 = (componentId, errors) => {
+	return errors.map((error) => `[Component: ${componentId.toString()}]${error}`);
+};
 /**
 * Creates and returns a builder for constructing `Component` objects.
 *
@@ -1005,7 +1052,7 @@ const isValidBlueprintComponent = (component) => {
 * - `withVersion(version: Version)`: Sets the version of the component.
 * - `withDisplayName(displayName: string)`: Sets the display name for the component.
 * - `withDescription(description: string)`: Sets a description for the component.
-* - `withParameters(parameters: GenericParameters)`: Sets the parameters associated with the component.
+* - `withParameters(parameters: Component.Parameters)`: Sets the parameters associated with the component.
 * - `withLinks(links: ComponentLink[])`: Sets the links associated with the component.
 * - `withDependencies(dependencies: BlueprintComponentDependency[])`: Sets the dependencies of the component.
 * - `reset()`: Resets all properties of the component to their default values based on `DEFAULT_BLUEPRINT_COMPONENT`.
@@ -1093,22 +1140,23 @@ let BlueprintComponent;
 
 //#endregion
 //#region src/fractal/service.ts
-const CLIENT_ID_HEADER = "X-ClientID";
-const CLIENT_SECRET_HEADER = "X-ClientSecret";
-const FRACTAL_API_URL = "https://api.fractal.cloud";
+const CLIENT_ID_HEADER$1 = "X-ClientID";
+const CLIENT_SECRET_HEADER$1 = "X-ClientSecret";
+const FRACTAL_API_URL$1 = "https://api.fractal.cloud";
 const deployFractal = async (credentials, fractal) => {
-	await superagent.post(`${FRACTAL_API_URL}/blueprints/${fractal.id.toString().replace(":", "/")}`).set(CLIENT_ID_HEADER, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER, credentials.secret).send({
+	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({
 		description: fractal.description,
 		isPrivate: fractal.isPrivate,
 		components: fractal.components.map((c) => ({
 			...c,
 			type: c.type.toString(),
-			id: c.id.value.kebabValue,
+			id: c.id.value.toString(),
 			version: c.version.toString(),
 			parameters: c.parameters.toMap(),
-			dependencies: c.dependencies.map((d) => d.id.value.kebabValue),
+			dependencies: c.dependencies.map((d) => d.id.value.toString()),
 			links: c.links.map((l) => ({
-				componentId: l.id.value.kebabValue,
+				componentId: l.id.value.toString(),
 				settings: l.parameters.toMap()
 			})),
 			outputFields: Object.keys(c.outputFields.value)
@@ -1116,7 +1164,7 @@ const deployFractal = async (credentials, fractal) => {
 	}).catch((e) => console.error(e.message, e.response.text));
 };
 const destroyFractal = async (credentials, id) => {
-	await superagent.delete(`${FRACTAL_API_URL}/blueprints/${id.toString().replace(":", "/")}`).set(CLIENT_ID_HEADER, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER, credentials.secret);
+	await superagent.delete(`${FRACTAL_API_URL$1}/blueprints/${id.toString().replace(":", "/")}`).set(CLIENT_ID_HEADER$1, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER$1, credentials.secret);
 };
 let FractalService;
 (function(_FractalService) {
@@ -1163,13 +1211,36 @@ const DEFAULT_FRACTAL = {
 * @returns {string[]} An array of error messages describing any validation issues with the fractal.
 */
 const isValidFractal = (fractal) => {
-	const idErrors = isValidFractalId(fractal.id);
-	const componentsErrors = !fractal.components || fractal.components.length === 0 ? [`[Fractal: ${fractal.id.toString()}]: components must not be empty`] : fractal.components.reduce((acc, x) => {
+	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));
 		return acc;
-	}, []);
+	}, []));
 	return [...idErrors, ...componentsErrors];
 };
+const addContextToErrors$4 = (value, errors) => {
+	return errors.map((error) => `[Fractal: ${value.toString()}]${error}`);
+};
+/**
+* Creates and returns a builder object for constructing Fractal objects.
+*
+* This builder provides a fluent interface for setting various properties of a Fractal
+* and includes methods for validation, resetting to defaults, and final construction.
+*
+* @returns {FractalBuilder} A builder object for incrementally building a Fractal.
+*
+* The builder object supports the following methods:
+* - `withId(value: FractalId): FractalBuilder` - Sets the ID of the Fractal.
+* - `withIsPrivate(value: boolean): FractalBuilder` - Sets the privacy status of the Fractal.
+* - `withDescription(value: string): FractalBuilder` - Sets the description of the Fractal.
+* - `withComponents(value: BlueprintComponent[]): FractalBuilder` - Appends a list of components to the Fractal.
+* - `withComponent(value: BlueprintComponent): FractalBuilder` - Appends a single component to the Fractal.
+* - `reset(): FractalBuilder` - Resets the builder’s state to the default Fractal properties.
+* - `build(): Fractal` - Validates and constructs a Fractal object.
+*
+* Throws:
+* - `SyntaxError` - If the constructed Fractal object is invalid during the build process.
+*/
 const getFractalBuilder = () => {
 	const internalState = { ...DEFAULT_FRACTAL };
 	const builder = {
@@ -1255,9 +1326,12 @@ const DEFAULT = {
 * @returns {boolean} Returns true if the bounded context is valid; otherwise, returns false.
 */
 const isValidBoundedContext = (value) => {
-	const idErrors = isValidBoundedContextId(value.id);
-	const displayNameErrors = isNonEmptyString(value.displayName) ? [] : ["Display name must be a non-empty string"];
-	return [...idErrors.map((x) => `[Bounded Context: ${value.id.toString()}] Id error: ${x}`), ...displayNameErrors.map((x) => `[Bounded Context: ${value.id.toString()}] Display Name error: ${x}`)];
+	const idErrors = addContextToErrors$3(value.id, isValidBoundedContextId(value.id));
+	const displayNameErrors = addContextToErrors$3(value.id, isNonEmptyString(value.displayName) ? [] : ["Display name must be a non-empty string"]);
+	return [...idErrors, ...displayNameErrors];
+};
+const addContextToErrors$3 = (bcId, errors) => {
+	return errors.map((error) => `[Bounded Context: ${bcId.toString()}]${error}`);
 };
 /**
 * Creates a builder for constructing a BoundedContext object with a fluid API.
@@ -1436,6 +1510,505 @@ let ServiceAccountCredentials$1;
 	_ServiceAccountCredentials.getBuilder = getServiceAccountCredentialsBuilder;
 })(ServiceAccountCredentials$1 || (ServiceAccountCredentials$1 = {}));
 
+//#endregion
+//#region src/environment/id.ts
+const equals = (a, b) => a.ownerType === b.ownerType && a.ownerId.value === b.ownerId.value && a.name.value === b.name.value;
+/**
+* Represents the default environment identifier used within the system.
+* The variable holds a constant, immutable object reflecting the default
+* properties and metadata of an environment.
+*
+* Properties:
+* - `ownerType`: An enumeration value specifying the type of owner (e.g., personal).
+* - `ownerId`: A constant value representing the default owner identifier.
+* - `name`: A default kebab-case formatted string for the environment name.
+* - `equals`: A function that always returns `false`, used to compare equality with another environment.
+* - `toString`: A function returning an empty string representation of the environment.
+*
+* The object is defined as `const` to ensure its immutability and integrity throughout its usage.
+*/
+const DEFAULT_ENVIRONMENT_ID = {
+	_type: "environment",
+	ownerType: OwnerType$1.Personal,
+	ownerId: DEFAULT_OWNER_ID,
+	name: DEFAULT_KEBAB_CASE_STRING,
+	equals: () => false,
+	toString: () => ""
+};
+/**
+* Validates whether the given environment ID is valid by checking its owner ID and name.
+*
+* @param {EnvironmentId} value - The environment ID to validate, which consists of an owner ID and a name.
+* @returns {string[]} An array of error messages, where each message describes a specific validation failure
+*                     for either the owner ID or the name. If no errors are present, the array is empty.
+*/
+const isValidEnvironmentId = (value) => {
+	const ownerIdErrors = addContextToErrors$2(value, isValidOwnerId(value.ownerId));
+	const nameErrors = addContextToErrors$2(value, isValidKebabCaseString(value.name.toString()));
+	return [...ownerIdErrors, ...nameErrors];
+};
+const addContextToErrors$2 = (value, errors) => {
+	return errors.map((error) => `[Environment Id: ${environmentIdToString(value)}]${error}`);
+};
+const environmentIdToString = (id) => `${id.ownerType.toString()}/${id.ownerId.value}/${id.name.value}`;
+/**
+* Creates and returns a builder for constructing a `Id` object.
+*
+* The builder allows customization of the `Id` properties such as `ownerType`,
+* while also enforcing constraints during the construction process, ensuring the resulting object is valid.
+* The builder is stateful and provides a method to reset to default values if needed.
+*
+* @returns {EnvironmentIdBuilder} A builder object that provides methods for modifying and constructing a `Id`.
+*
+* @throws {SyntaxError} Throws an error if the resulting `Id` is invalid when the `build` method is invoked.
+*/
+const getEnvironmentIdBuilder = () => {
+	const internalState = { ...DEFAULT_ENVIRONMENT_ID };
+	const builder = {
+		withOwnerType: (ownerType) => {
+			internalState.ownerType = ownerType;
+			return builder;
+		},
+		withOwnerId: (ownerId) => {
+			internalState.ownerId = ownerId;
+			return builder;
+		},
+		withName: (name) => {
+			internalState.name = name;
+			return builder;
+		},
+		reset: () => {
+			internalState.ownerType = DEFAULT_ENVIRONMENT_ID.ownerType;
+			internalState.ownerId = DEFAULT_ENVIRONMENT_ID.ownerId;
+			internalState.name = DEFAULT_ENVIRONMENT_ID.name;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidEnvironmentId(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			const builtId = {
+				...internalState,
+				equals: (other) => equals(builtId, other),
+				toString: () => environmentIdToString(builtId)
+			};
+			return builtId;
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/environment/entity.ts
+const DEFAULT_ENVIRONMENT = {
+	id: DEFAULT_ENVIRONMENT_ID,
+	parameters: getParametersInstance()
+};
+const isValidEnvironment = (environment) => addContextToErrors$1(environment.id, isValidEnvironmentId(environment.id));
+const addContextToErrors$1 = (environmentId, errors) => {
+	return errors.map((error) => `[Environment: ${environmentId.toString()}]${error}`);
+};
+const getEnvironmentBuilder = () => {
+	const internalState = { ...DEFAULT_ENVIRONMENT };
+	const builder = {
+		withId: (id) => {
+			internalState.id = id;
+			return builder;
+		},
+		withParameters: (parameters) => {
+			internalState.parameters = parameters;
+			return builder;
+		},
+		reset: () => {
+			internalState.id = DEFAULT_ENVIRONMENT.id;
+			internalState.parameters = DEFAULT_ENVIRONMENT.parameters;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidEnvironment(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return { ...internalState };
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/environment/index.ts
+let Environment$1;
+(function(_Environment) {
+	let Id;
+	(function(_Id) {
+		_Id.getBuilder = getEnvironmentIdBuilder;
+	})(Id || (Id = _Environment.Id || (_Environment.Id = {})));
+	_Environment.getBuilder = getEnvironmentBuilder;
+})(Environment$1 || (Environment$1 = {}));
+
+//#endregion
+//#region src/live_system/id.ts
+const toString = (id) => `${id.boundedContextId.toString()}/${id.name.value}`;
+/**
+* Validates the specified LiveSystemId and returns a list of error messages.
+*
+* The validation process includes checking the validity of the bounded context ID
+* and the name associated with the LiveSystemId.
+*
+* @param {LiveSystemId} id - The LiveSystemId object to be validated. It contains
+*                            a bounded context ID and a name in kebab-case format.
+* @returns {string[]} An array of error messages generated during validation. Each error message
+*                     is prepended with the string representation of the provided LiveSystemId for context.
+*/
+const isValidLiveSystemId = (id) => {
+	const boundedContextIdErrors = isValidBoundedContextId(id.boundedContextId);
+	const nameErrors = isValidKebabCaseString(id.name.value);
+	return [...boundedContextIdErrors.map((x) => `[Live System Id: ${id.toString()}] Bounded Context Id error: ${x}`), ...nameErrors.map((x) => `[Live System Id: ${id.toString()}] Name errors: ${x}`)];
+};
+/**
+* Represents the default identifier for a live system within a bounded context.
+*
+* This constant is used to define the default configuration for a live system by associating a
+* predefined bounded context identifier with a default name in kebab-case format.
+*
+* Fields:
+* - `boundedContextId`: Identifies the default bounded context to which the live system belongs.
+* - `name`: Specifies the default name of the live system in a standardized kebab-case string format.
+*/
+const DEFAULT_LIVE_SYSTEM_ID = {
+	boundedContextId: DEFAULT_BOUNDED_CONTEXT_ID,
+	name: DEFAULT_KEBAB_CASE_STRING
+};
+/**
+* Creates and returns a `LiveSystemIdBuilder` to construct and validate `LiveSystemId` objects.
+*
+* The builder provides a fluent API for setting properties and validating the resulting `LiveSystemId`.
+*
+* @returns {LiveSystemIdBuilder} A builder object with methods to configure, reset, and build a `LiveSystemId`.
+*
+* Methods available in the builder:
+* - `withBoundedContextId(value: BoundedContext.Id)`: Sets the bounded context ID for the `LiveSystemId`.
+* - `withName(value: KebabCaseString)`: Sets the name for the `LiveSystemId`.
+* - `reset()`: Resets all properties to their default values as defined in `DEFAULT_LIVE_SYSTEM_ID`.
+* - `build()`: Validates the current state of the builder and constructs a `LiveSystemId` object. Throws a `SyntaxError` if validation fails.
+*/
+const getLiveSystemIdBuilder = () => {
+	const internalState = { ...DEFAULT_LIVE_SYSTEM_ID };
+	const builder = {
+		withBoundedContextId: (value) => {
+			internalState.boundedContextId = value;
+			return builder;
+		},
+		withName: (value) => {
+			internalState.name = value;
+			return builder;
+		},
+		reset: () => {
+			internalState.boundedContextId = DEFAULT_LIVE_SYSTEM_ID.boundedContextId;
+			internalState.name = DEFAULT_LIVE_SYSTEM_ID.name;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidLiveSystemId(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			const builtId = {
+				...internalState,
+				toString: () => toString(builtId)
+			};
+			return builtId;
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/live_system/component/entity.ts
+const DEFAULT_LIVE_SYSTEM_COMPONENT = {
+	...DEFAULT_BLUEPRINT_COMPONENT,
+	status: "Instantiating",
+	lastUpdated: /* @__PURE__ */ new Date(0),
+	lastOperationRetried: -1,
+	provider: "Unknown",
+	lastOperationStatusMessage: "",
+	errorCode: ""
+};
+const isValidLiveSystemComponent = (component) => isValidBlueprintComponent(component);
+const getLiveSystemComponentBuilder = () => {
+	const internalState = { ...DEFAULT_LIVE_SYSTEM_COMPONENT };
+	const builder = {
+		withType: (type) => {
+			internalState.type = type;
+			return builder;
+		},
+		withId: (id) => {
+			internalState.id = id;
+			return builder;
+		},
+		withVersion: (version) => {
+			internalState.version = version;
+			return builder;
+		},
+		withIsLocked: (value) => {
+			internalState.isLocked = value;
+			return builder;
+		},
+		withRecreateOnFailure: (value) => {
+			internalState.recreateOnFailure = value;
+			return builder;
+		},
+		withProvider: (value) => {
+			internalState.provider = value;
+			return builder;
+		},
+		withDisplayName: (displayName) => {
+			internalState.displayName = displayName;
+			return builder;
+		},
+		withDescription: (description) => {
+			internalState.description = description;
+			return builder;
+		},
+		withParameters: (parameters) => {
+			internalState.parameters = parameters;
+			return builder;
+		},
+		withLinks: (links) => {
+			internalState.links = links;
+			return builder;
+		},
+		withDependencies: (dependencies) => {
+			internalState.dependencies = dependencies;
+			return builder;
+		},
+		reset: () => {
+			internalState.type = DEFAULT_LIVE_SYSTEM_COMPONENT.type;
+			internalState.id = DEFAULT_LIVE_SYSTEM_COMPONENT.id;
+			internalState.version = DEFAULT_LIVE_SYSTEM_COMPONENT.version;
+			internalState.displayName = DEFAULT_LIVE_SYSTEM_COMPONENT.displayName;
+			internalState.description = DEFAULT_LIVE_SYSTEM_COMPONENT.description;
+			internalState.parameters = DEFAULT_LIVE_SYSTEM_COMPONENT.parameters;
+			internalState.links = DEFAULT_LIVE_SYSTEM_COMPONENT.links;
+			internalState.dependencies = DEFAULT_LIVE_SYSTEM_COMPONENT.dependencies;
+			internalState.isLocked = DEFAULT_LIVE_SYSTEM_COMPONENT.isLocked;
+			internalState.provider = DEFAULT_LIVE_SYSTEM_COMPONENT.provider;
+			internalState.recreateOnFailure = DEFAULT_LIVE_SYSTEM_COMPONENT.recreateOnFailure;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidLiveSystemComponent(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return { ...internalState };
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/live_system/service.ts
+const CLIENT_ID_HEADER = "X-ClientID";
+const CLIENT_SECRET_HEADER = "X-ClientSecret";
+const FRACTAL_API_URL = "https://api.fractal.cloud";
+const deployLiveSystem = async (credentials, liveSystem) => {
+	const body = {
+		liveSystemId: liveSystem.id.toString(),
+		fractalId: liveSystem.fractalId.toString(),
+		description: liveSystem.description,
+		provider: liveSystem.genericProvider,
+		blueprintMap: liveSystem.components.reduce((acc, c) => {
+			acc[c.id.value.toString()] = {
+				...c,
+				type: c.type.toString(),
+				id: c.id.value.toString(),
+				version: c.version.toString(),
+				parameters: c.parameters.toMap(),
+				dependencies: c.dependencies.map((d) => d.id.value.toString()),
+				links: c.links.map((l) => ({
+					componentId: l.id.value.toString(),
+					settings: l.parameters.toMap()
+				})),
+				outputFields: c.outputFields.value
+			};
+			return acc;
+		}, {}),
+		parameters: liveSystem.parameters.toMap(),
+		environment: {
+			id: {
+				type: liveSystem.environment.id.ownerType,
+				ownerId: liveSystem.environment.id.ownerId.toString(),
+				shortName: liveSystem.environment.id.name.toString()
+			},
+			parameters: liveSystem.environment.parameters.toMap()
+		}
+	};
+	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));
+};
+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);
+};
+let LiveSystemService;
+(function(_LiveSystemService) {
+	_LiveSystemService.deploy = deployLiveSystem;
+	_LiveSystemService.destroy = destroyLiveSystem;
+})(LiveSystemService || (LiveSystemService = {}));
+
+//#endregion
+//#region src/live_system/entity.ts
+const DEFAULT_LIVE_SYSTEM = {
+	id: DEFAULT_LIVE_SYSTEM_ID,
+	requesterId: "",
+	fractalId: DEFAULT_FRACTAL_ID,
+	description: "",
+	status: "Unknown",
+	statusMessage: "",
+	components: [],
+	genericProvider: "Unknown",
+	parameters: getParametersInstance(),
+	createdAt: /* @__PURE__ */ new Date(),
+	updatedAt: /* @__PURE__ */ new Date(),
+	environment: DEFAULT_ENVIRONMENT,
+	deploy: () => Promise.reject(),
+	destroy: () => Promise.reject()
+};
+/**
+* Validates a given live system and returns a list of error messages if any validation fails.
+*
+* This function verifies the following:
+* - The `id` of the live system is valid.
+* - The `fractalId` of the live system is valid.
+* - The `components` field is not empty and all its components pass validation.
+*
+* @param {LiveSystem} liveSystem - The live system object to be validated.
+* @returns {string[]} An array of error messages. If validation passes, this array will be empty.
+*/
+const isValidLiveSystem = (liveSystem) => {
+	const idErrors = addContextToErrors(liveSystem.id, isValidLiveSystemId(liveSystem.id));
+	const fractalIdErrors = addContextToErrors(liveSystem.id, isValidFractalId(liveSystem.fractalId));
+	const environmentErrors = addContextToErrors(liveSystem.id, isValidEnvironment(liveSystem.environment));
+	const componentsErrors = addContextToErrors(liveSystem.id, !liveSystem.components || liveSystem.components.length === 0 ? ["[Components] Components must not be empty"] : liveSystem.components.reduce((acc, x) => {
+		acc.push(...isValidLiveSystemComponent(x));
+		return acc;
+	}, []));
+	return [
+		...idErrors,
+		...fractalIdErrors,
+		...componentsErrors,
+		...environmentErrors
+	];
+};
+const addContextToErrors = (liveSystemId, errors) => {
+	return errors.map((error) => `[Live System: ${liveSystemId.toString()}]${error}`);
+};
+/**
+* Creates and returns a builder for constructing LiveSystem objects.
+* The builder allows the user to configure various properties of a LiveSystem
+* instance through a fluent API.
+*
+* @returns {LiveSystemBuilder} An object providing methods to configure and build a LiveSystem instance.
+*
+* @description
+* The `getLiveSystemBuilder` function initializes a builder object for constructing LiveSystem instances.
+* The builder maintains an internal state that gets updated through its methods. When the `build` method
+* is invoked, the internal state is validated and returned as a fully formed LiveSystem object.
+*
+* The builder provides the following configuration methods:
+* - `withId(value: LiveSystemId)`: Sets the `id` property of the LiveSystem.
+* - `withDescription(value: string)`: Sets the `description` property of the LiveSystem.
+* - `withFractalId(value: Fractal.Id)`: Sets the `fractalId` property of the LiveSystem.
+* - `withComponents(value: LiveSystemComponent[])`: Adds an array of components to the LiveSystem.
+* - `withComponent(value: LiveSystemComponent)`: Adds a single component to the LiveSystem.
+* - `withGenericProvider(value: LiveSystemComponent.Provider)`: Sets the `genericProvider` property of the LiveSystem.
+* - `withParameters(parameters: ComponentParameters): Assigns the provided `parameters` to the `LiveSystem`.
+*
+* Additional builder methods:
+* - `reset()`: Resets the internal state to the default LiveSystem configuration.
+* - `build()`: Validates the internal state and returns a LiveSystem instance. If validation fails, an error is thrown.
+*
+* Validation:
+* The `build` method performs validation on the internal state using the `isValidLiveSystem` function. If validation
+* errors are detected, a `SyntaxError` is thrown containing the list of errors.
+*
+* Lifecycle Operations:
+* The constructed LiveSystem object includes the `deploy` and `destroy` methods:
+* - `deploy(credentials)`: Deploys the LiveSystem using the given credentials.
+* - `destroy(credentials)`: Destroys the LiveSystem using the given credentials and its `id`.
+*/
+const getLiveSystemBuilder = () => {
+	const internalState = { ...DEFAULT_LIVE_SYSTEM };
+	const builder = {
+		withId: (value) => {
+			internalState.id = value;
+			return builder;
+		},
+		withFractalId: (value) => {
+			internalState.fractalId = value;
+			return builder;
+		},
+		withDescription: (value) => {
+			internalState.description = value;
+			return builder;
+		},
+		withComponents: (value) => {
+			if (!internalState.components) internalState.components = [];
+			internalState.components.push(...value);
+			return builder;
+		},
+		withComponent: (value) => {
+			if (!internalState.components) internalState.components = [];
+			internalState.components.push(value);
+			return builder;
+		},
+		withGenericProvider: (value) => {
+			internalState.genericProvider = value;
+			return builder;
+		},
+		withParameters: (parameters) => {
+			internalState.parameters = parameters;
+			return builder;
+		},
+		withEnvironment: (environment) => {
+			internalState.environment = environment;
+			return builder;
+		},
+		reset: () => {
+			internalState.id = DEFAULT_LIVE_SYSTEM.id;
+			internalState.requesterId = DEFAULT_LIVE_SYSTEM.requesterId;
+			internalState.fractalId = DEFAULT_LIVE_SYSTEM.fractalId;
+			internalState.description = DEFAULT_LIVE_SYSTEM.description;
+			internalState.status = DEFAULT_LIVE_SYSTEM.status;
+			internalState.statusMessage = DEFAULT_LIVE_SYSTEM.statusMessage;
+			internalState.components = DEFAULT_LIVE_SYSTEM.components;
+			internalState.genericProvider = DEFAULT_LIVE_SYSTEM.genericProvider;
+			internalState.environment = DEFAULT_LIVE_SYSTEM.environment;
+			internalState.createdAt = DEFAULT_LIVE_SYSTEM.createdAt;
+			internalState.updatedAt = DEFAULT_LIVE_SYSTEM.updatedAt;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidLiveSystem(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return {
+				...internalState,
+				deploy: (credentials) => LiveSystemService.deploy(credentials, internalState),
+				destroy: (credentials) => LiveSystemService.destroy(credentials, internalState.id)
+			};
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/live_system/index.ts
+let LiveSystem$1;
+(function(_LiveSystem) {
+	let Id;
+	(function(_Id) {
+		_Id.getBuilder = getLiveSystemIdBuilder;
+	})(Id || (Id = _LiveSystem.Id || (_LiveSystem.Id = {})));
+	let Component;
+	(function(_Component) {
+		_Component.getBuilder = getLiveSystemComponentBuilder;
+	})(Component || (Component = _LiveSystem.Component || (_LiveSystem.Component = {})));
+	_LiveSystem.getBuilder = getLiveSystemBuilder;
+})(LiveSystem$1 || (LiveSystem$1 = {}));
+
 //#endregion
 //#region src/index.ts
 const BoundedContext = BoundedContext$1;
@@ -1449,6 +2022,8 @@ const ServiceAccountCredentials = ServiceAccountCredentials$1;
 const ServiceAccountId = ServiceAccountId$1;
 const ServiceDeliveryModel = ServiceDeliveryModel$1;
 const Version = Version$1;
+const Environment = Environment$1;
+const LiveSystem = LiveSystem$1;
 
 //#endregion
-export { BoundedContext, Fractal, InfrastructureDomain, KebabCaseString, OwnerId, OwnerType, PascalCaseString, ServiceAccountCredentials, ServiceAccountId, ServiceDeliveryModel, Version };
+export { BoundedContext, Environment, Fractal, InfrastructureDomain, KebabCaseString, LiveSystem, OwnerId, OwnerType, PascalCaseString, ServiceAccountCredentials, ServiceAccountId, ServiceDeliveryModel, Version };