@fractal_cloud/sdk 0.1.1 → 1.0.0

package/dist/index.mjs

@@ -0,0 +1,2029 @@
+import superagent from "superagent";
+
+//#region src/values/kebab_case_string.ts
+/**
+* A constant variable representing a default kebab-case string.
+*
+* The `DEFAULT_KEBAB_CASE_STRING` is initialized with a `value` key,
+* containing an empty string as its default value.
+*
+* This variable is declared as a constant to prevent modification
+* and is designed to not pass validation checks.
+*
+* @type {KebabCaseString}
+*/
+const DEFAULT_KEBAB_CASE_STRING = {
+	_type: "kebab",
+	value: "",
+	equals: () => false,
+	toString: () => ""
+};
+/**
+* Validates whether a given string follows the kebab-case format.
+*
+* A string is considered as valid kebab-case if it:
+* - Starts with a lowercase letter.
+* - Contains only lowercase letters, numbers, and hyphens.
+* - Does not have consecutive hyphens.
+* - Does not end or begin with a hyphen.
+*
+* @param {string} value - The string to validate.
+* @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 '${value}' must be in kebab-case`];
+	return [];
+};
+/**
+* Creates a builder for constructing a KebabCaseString object. The builder enforces Kebab case formatting and ensures
+* a valid string is set before building. Once built, the KebabCaseString object becomes immutable.
+*
+* @function getKebabCaseStringBuilder
+* @returns {Object} A builder object with the following methods:
+* - `withValue(value: string): Object` – Sets the value of the KebabCaseString. Throws a `RangeError` if the input is not in Kebab case format (e.g., "example-string").
+* - `reset(): void` – Resets the builder to its default state, clearing the current value.
+* - `build(): KebabCaseString` – Constructs and returns a KebabCaseString object based on the current state. Throws a `SyntaxError` if no value has been set before building.
+*/
+const getKebabCaseStringBuilder = () => {
+	const internalState = { ...DEFAULT_KEBAB_CASE_STRING };
+	const builder = {
+		withValue: (value) => {
+			internalState.value = value;
+			return builder;
+		},
+		reset: () => {
+			internalState.value = DEFAULT_KEBAB_CASE_STRING.value;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidKebabCaseString(internalState.value);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return {
+				...internalState,
+				equals: (other) => internalState.value === other.value,
+				toString: () => internalState.value
+			};
+		}
+	};
+	return builder;
+};
+let KebabCaseString$1;
+(function(_KebabCaseString) {
+	_KebabCaseString.getBuilder = getKebabCaseStringBuilder;
+})(KebabCaseString$1 || (KebabCaseString$1 = {}));
+
+//#endregion
+//#region src/values/version.ts
+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.
+*
+* This variable is declared as a constant to prevent modification
+* and is designed to not pass validation checks.
+*/
+const DEFAULT_VERSION = {
+	major: 0,
+	minor: 0,
+	patch: 0,
+	equals: (other) => equals$4(DEFAULT_VERSION, other)
+};
+/**
+* Validates if the provided version object is properly initialized or equivalent to the default version.
+*
+* @param {Version} version - The version object to be validated.
+* @returns {string[]} An array of error messages. If the version is equivalent to the default version, it returns
+*                     an array containing one error message. Otherwise, it returns an empty array.
+*/
+const isValidVersion = (version) => {
+	if (equals$4(version, DEFAULT_VERSION)) return [" Version must be initialized"];
+	return [];
+};
+/**
+* Creates a builder object for constructing and managing version objects.
+* The builder allows for setting major, minor, and patch versions, resetting to defaults,
+* and building the final version object. The default version is considered uninitialized and
+* an error is thrown if build is called without initializing the version.
+*
+* @function getVersionBuilder
+* @returns {VersionBuilder} Returns a builder object with methods to define and construct a version.
+*
+* - `withMajor(major: number): builder`
+*   Sets the major version number and returns the builder.
+*
+* - `withMinor(minor: number): builder`
+*   Sets the minor version number and returns the builder.
+*
+* - `withPatch(patch: number): builder`
+*   Sets the patch version number and returns the builder.
+*
+* - `reset(): builder`
+*   Resets the version to the default values (major: 0, minor: 0, patch: 0) and returns the builder.
+*
+* - `build(): Version`
+*   Constructs and returns the final version object. Throws a `SyntaxError` if the version
+*   is not initialized (when it matches the default version).
+*/
+const getVersionBuilder = () => {
+	const internalState = { ...DEFAULT_VERSION };
+	const builder = {
+		withMajor: (major) => {
+			internalState.major = major;
+			if (major < 0) throw new RangeError("Major version must be non-negative");
+			return builder;
+		},
+		withMinor: (minor) => {
+			if (minor < 0) throw new RangeError("Minor version must be non-negative");
+			internalState.minor = minor;
+			return builder;
+		},
+		withPatch: (patch) => {
+			if (patch < 0) throw new RangeError("Patch version must be non-negative");
+			internalState.patch = patch;
+			return builder;
+		},
+		reset: () => {
+			internalState.major = DEFAULT_VERSION.major;
+			internalState.minor = DEFAULT_VERSION.minor;
+			internalState.patch = DEFAULT_VERSION.patch;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidVersion(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			const builtVersion = {
+				...internalState,
+				equals: (other) => equals$4(builtVersion, other),
+				toString: () => toString$2(builtVersion)
+			};
+			return builtVersion;
+		}
+	};
+	return builder;
+};
+let Version$1;
+(function(_Version) {
+	_Version.getBuilder = getVersionBuilder;
+})(Version$1 || (Version$1 = {}));
+
+//#endregion
+//#region src/values/owner_type.ts
+/**
+* Enum representing the type of ownership for an entity.
+*
+* This enumeration can be used to differentiate between entities owned by individuals
+* and those owned by organizations.
+*
+* @enum {string}
+* @readonly
+* @property {string} Personal - Represents ownership by an individual person.
+* @property {string} Organizational - Represents ownership by an organization or group.
+*/
+let OwnerType$1 = /* @__PURE__ */ function(OwnerType) {
+	OwnerType["Personal"] = "Personal";
+	OwnerType["Organizational"] = "Organizational";
+	return 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`];
+	return [];
+};
+
+//#endregion
+//#region src/values/owner_id.ts
+/**
+* A constant variable representing the default owner ID.
+*
+* This variable is declared as a constant to prevent modification
+* and is designed to not pass validation checks.
+*/
+const DEFAULT_OWNER_ID = {
+	_type: "ownerId",
+	value: "",
+	toString: () => ""
+};
+/**
+* Validates whether the given string value is a valid UUID.
+*
+* This function checks if the provided `value` conforms to the UUID format.
+* If the validation fails, an array containing an error message will be returned.
+* If the validation passes, an empty array is returned.
+*
+* @param {string} value - The string value to be validated.
+* @returns {string[]} An array containing error messages if invalid, or an empty array if valid.
+*/
+const isValidOwnerId = (value) => {
+	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
+* a valid string is set before building. Once built, the OwnerId object becomes immutable.
+*
+* @function getOwnerIdBuilder
+* @returns {Object} A builder object with the following methods:
+* - `withValue(value: string): Object` – Sets the value of the OwnerId. Throws a `RangeError` if the input is not in uuid format (e.g., "550e8400-e29b-41d4-a716-446655440000").
+* - `reset(): void` – Resets the builder to its default state, clearing the current value.
+* - `build(): OwnerId` – Constructs and returns a OwnerId object based on the current state. Throws a `SyntaxError` if no value has been set before building.
+*/
+const getOwnerIdBuilder = () => {
+	const internalState = { ...DEFAULT_OWNER_ID };
+	const builder = {
+		withValue: (value) => {
+			internalState.value = value;
+			return builder;
+		},
+		reset: () => {
+			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,
+				toString: () => internalState.value
+			};
+		}
+	};
+	return builder;
+};
+let OwnerId$1;
+(function(_OwnerId) {
+	_OwnerId.getBuilder = getOwnerIdBuilder;
+})(OwnerId$1 || (OwnerId$1 = {}));
+
+//#endregion
+//#region src/bounded_context/id.ts
+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: () => false,
+	toString: () => ""
+};
+/**
+* Determines whether the given value is a valid Id.
+*
+* @param {BoundedContextId} value - The Id to validate.
+* @returns {boolean} True if the Id is valid; otherwise, false.
+*
+* A Id is considered valid if:
+* - The `ownerId` component of the value is a valid owner identifier, as verified
+*   by the `isValidOwnerId` function.
+* - The `name` component of the value is in kebab-case format, as verified by
+*   the `isValidKebabCaseString` function.
+*/
+const isValidBoundedContextId = (value) => {
+	const ownerIdErrors = addContextToErrors$7(value, isValidOwnerId(value.ownerId));
+	const nameErrors = addContextToErrors$7(value, isValidKebabCaseString(value.name.value));
+	return [...ownerIdErrors, ...nameErrors];
+};
+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.
+*
+* 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 {BoundedContextIdBuilder} 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 getBoundedContextIdBuilder = () => {
+	const internalState = { ...DEFAULT_BOUNDED_CONTEXT_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_BOUNDED_CONTEXT_ID.ownerType;
+			internalState.ownerId = DEFAULT_BOUNDED_CONTEXT_ID.ownerId;
+			internalState.name = DEFAULT_BOUNDED_CONTEXT_ID.name;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidBoundedContextId(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			const builtId = {
+				...internalState,
+				equals: (other) => equals$3(builtId, other),
+				toString: () => boundedContextIdToString(builtId)
+			};
+			return builtId;
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/fractal/id.ts
+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.
+*
+* @param {FractalId} id - The Fractal ID to validate.
+* @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 = 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,
+		...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.
+*
+* This constant holds a predefined FractalId object used as a default configuration
+* in systems where fractal identification is required. The FractalId includes
+* properties such as the bounded context ID, name, and version.
+*
+* The `boundedContextId` corresponds to the default bounded context identifier.
+* The `name` is represented as a default kebab-case string format.
+* The `version` reflects the defined default version of the fractal.
+*
+* DEFAULT_FRACTAL_ID can be used as a fallback or initial value in scenarios
+* where no specific fractal identifier is provided.
+*
+* @constant {FractalId} DEFAULT_FRACTAL_ID
+*/
+const DEFAULT_FRACTAL_ID = {
+	boundedContextId: DEFAULT_BOUNDED_CONTEXT_ID,
+	name: DEFAULT_KEBAB_CASE_STRING,
+	version: DEFAULT_VERSION,
+	equals: () => false,
+	toString: () => ""
+};
+/**
+* Provides a builder for constructing a `FractalId` object.
+* This builder allows incremental creation of the ID through a fluent API
+* with methods for specifying bounded context ID, name, and version, as well as
+* resetting and building the final object.
+*
+* @returns {FractalIdBuilder} A builder object with methods for constructing a `FractalId`.
+*
+* Methods available on the builder:
+* - `withBoundedContextId(value: BoundedContext.Id)`: Sets the bounded context ID for the `FractalId`.
+* - `withName(value: KebabCaseString)`: Sets the name for the `FractalId`.
+* - `withVersion(value: Version)`: Sets the version for the `FractalId`.
+* - `reset()`: Resets the builder's internal state to default values.
+* - `build()`: Validates and constructs the final `FractalId` object. Throws a `SyntaxError` if validation fails.
+*/
+const getFractalIdBuilder = () => {
+	const internalState = { ...DEFAULT_FRACTAL_ID };
+	const builder = {
+		withBoundedContextId: (value) => {
+			internalState.boundedContextId = value;
+			return builder;
+		},
+		withName: (value) => {
+			internalState.name = value;
+			return builder;
+		},
+		withVersion: (value) => {
+			internalState.version = value;
+			return builder;
+		},
+		reset: () => {
+			internalState.boundedContextId = DEFAULT_FRACTAL_ID.boundedContextId;
+			internalState.name = DEFAULT_FRACTAL_ID.name;
+			internalState.version = DEFAULT_FRACTAL_ID.version;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidFractalId(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			const builtId = {
+				...internalState,
+				equals: (other) => equals$2(builtId, other),
+				toString: () => toString$1(builtId)
+			};
+			return builtId;
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/values/service_delivery_model.ts
+/**
+* Enum representing the different types of service delivery models in cloud computing.
+*
+* @enum {string}
+* @readonly
+* @property {string} IaaS Infrastructure as a Service - A model that provides virtualized computing infrastructure over the internet.
+* @property {string} CaaS Container as a Service - A model focused on deploying and managing containers as a service.
+* @property {string} PaaS Platform as a Service - A cloud model that provides a platform allowing users to develop, run, and manage applications without dealing with the underlying infrastructure.
+* @property {string} FaaS Function as a Service - A serverless model where cloud functions are executed in response to events.
+* @property {string} SaaS Software as a Service - A model in which software applications are delivered over the internet on a subscription basis.
+*/
+let ServiceDeliveryModel$1 = /* @__PURE__ */ function(ServiceDeliveryModel) {
+	ServiceDeliveryModel["IaaS"] = "IaaS";
+	ServiceDeliveryModel["CaaS"] = "CaaS";
+	ServiceDeliveryModel["PaaS"] = "PaaS";
+	ServiceDeliveryModel["FaaS"] = "FaaS";
+	ServiceDeliveryModel["SaaS"] = "SaaS";
+	return ServiceDeliveryModel;
+}({});
+
+//#endregion
+//#region src/values/pascal_case_string.ts
+/**
+* Validates whether a given string is in PascalCase format.
+* A PascalCase string must start with an uppercase letter and contain
+* only alphabetic characters.
+*
+* @param {string} value - The string to validate.
+* @returns {string[]} An array containing an error message if the string
+*                     does not conform to PascalCase, or an empty array
+*                     if the string is valid.
+*/
+const isValidPascalCaseString = (value) => {
+	if (!/^[A-Z][a-zA-Z]*$/.test(value)) return [` Value '${value}' must be in PascalCase`];
+	return [];
+};
+/**
+* A constant object representing a default PascalCase formatted string.
+*
+* This variable is declared as a constant to prevent modification
+* and is designed to not pass validation checks.
+*/
+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.
+*
+* @function getPascalCaseStringBuilder
+* @returns {Object} A builder object with the following methods:
+* - `withValue(value: string): Object` – Sets the value of the PascalCaseString. Throws a `RangeError` if the input is not in Pascal case format (e.g., "ExampleString").
+* - `reset(): void` – Resets the builder to its default state, clearing the current value.
+* - `build(): PascalCaseString` – Constructs and returns a PascalCaseString object based on the current state. Throws a `SyntaxError` if no value has been set before building.
+*/
+const getPascalCaseStringBuilder = () => {
+	const internalState = { ...DEFAULT_PASCAL_CASE_STRING };
+	const builder = {
+		withValue: (value) => {
+			internalState.value = value;
+			return builder;
+		},
+		reset: () => {
+			internalState.value = DEFAULT_PASCAL_CASE_STRING.value;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidPascalCaseString(internalState.value);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return {
+				...internalState,
+				equals: (other) => internalState.value === other.value,
+				toString: () => internalState.value
+			};
+		}
+	};
+	return builder;
+};
+let PascalCaseString$1;
+(function(_PascalCaseString) {
+	_PascalCaseString.getBuilder = getPascalCaseStringBuilder;
+})(PascalCaseString$1 || (PascalCaseString$1 = {}));
+
+//#endregion
+//#region src/values/infrastructure_domain.ts
+/**
+* Enumeration representing various infrastructure domains.
+* These domains categorize components or services
+* within an infrastructure system.
+*
+* @enum {string}
+* @property {string} ApiManagement - Represents API management-related components.
+* @property {string} NetworkAndCompute - Represents network and compute components.
+* @property {string} CustomWorkloads - Represents custom workload components.
+* @property {string} Messaging - Represents messaging and communication components.
+* @property {string} Storage - Represents data storage components.
+* @property {string} Observability - Represents observability tools and monitoring components.
+* @property {string} Security - Represents security-focused components.
+*/
+let InfrastructureDomain$1 = /* @__PURE__ */ function(InfrastructureDomain) {
+	InfrastructureDomain["ApiManagement"] = "APIManagement";
+	InfrastructureDomain["NetworkAndCompute"] = "NetworkAndCompute";
+	InfrastructureDomain["CustomWorkloads"] = "CustomWorkloads";
+	InfrastructureDomain["Messaging"] = "Messaging";
+	InfrastructureDomain["Storage"] = "Storage";
+	InfrastructureDomain["Observability"] = "Observability";
+	InfrastructureDomain["Security"] = "Security";
+	return InfrastructureDomain;
+}({});
+
+//#endregion
+//#region src/component/type.ts
+/**
+* Represents the default type configuration for a component.
+*
+* This variable is declared as a constant to prevent modification
+* and is designed to not pass validation checks.
+*/
+const DEFAULT_COMPONENT_TYPE = {
+	domain: InfrastructureDomain$1.ApiManagement,
+	name: DEFAULT_PASCAL_CASE_STRING
+};
+/**
+* Validates the provided component type and checks for errors in the type's name.
+*
+* The validation ensures that the name of the component type follows the PascalCase string format.
+* If any violations are detected, it returns an array of error messages. Each error message is
+* formatted to include the component type's name and a descriptive error message.
+*
+* @param {ComponentType} type - The component type object to be validated.
+* @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.value);
+	if (nameError.length > 0) return nameError.map((x) => `[Component Type: ${type.name.value}][Name]${x}`);
+	return [];
+};
+/**
+* Creates and returns a builder for constructing a `TypeBuilder` instance.
+*
+* This builder provides methods to configure and customize the properties
+* of a `ComponentType` object before it is finalized and built.
+*
+* @returns {ComponentTypeBuilder} A builder instance for constructing a `ComponentType`.
+*
+* @property {Function} withInfrastructureDomain - Sets the `domain` property
+* of the internal state with the provided `InfrastructureDomain` value.
+*
+* @property {Function} withName - Sets the `name` property of the internal
+* state with the provided `PascalCaseString` value.
+*
+* @property {Function} reset - Resets the internal state of the builder to
+* the default `ComponentType` values.
+*
+* @property {Function} build - Validates the internal state of the builder
+* and returns a finalized `ComponentType` object. Throws a `SyntaxError` if
+* validation fails.
+*/
+const getComponentTypeBuilder = () => {
+	const internalState = { ...DEFAULT_COMPONENT_TYPE };
+	const builder = {
+		withInfrastructureDomain: (domain) => {
+			internalState.domain = domain;
+			return builder;
+		},
+		withName: (name) => {
+			internalState.name = name;
+			return builder;
+		},
+		reset: () => {
+			internalState.domain = DEFAULT_COMPONENT_TYPE.domain;
+			internalState.name = DEFAULT_COMPONENT_TYPE.name;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidComponentType(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return { ...internalState };
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/fractal/component/type.ts
+/**
+*/
+const DEFAULT_BLUEPRINT_COMPONENT_TYPE = {
+	...DEFAULT_COMPONENT_TYPE,
+	serviceDeliveryModel: ServiceDeliveryModel$1.SaaS
+};
+/**
+* Validates the provided component type and checks for errors in the type's name.
+*
+* The validation ensures that the name of the component type follows the PascalCase string format.
+* If any violations are detected, it returns an array of error messages. Each error message is
+* formatted to include the component type's name and a descriptive error message.
+*
+* @param {BlueprintComponentType} type - The component type object to be validated.
+* @returns {string[]} An array of error messages if validation fails; an empty array if the name is valid.
+*/
+const isValidBlueprintComponentType = (type) => isValidComponentType(type);
+/**
+* Creates and returns a builder for constructing a `TypeBuilder` instance.
+*
+* This builder provides methods to configure and customize the properties
+* of a `ComponentType` object before it is finalized and built.
+*
+* @returns {BlueprintComponentTypeBuilder} A builder instance for constructing a `ComponentType`.
+*
+* @property {Function} withInfrastructureDomain - Sets the `domain` property
+* of the internal state with the provided `InfrastructureDomain` value.
+*
+* @property {Function} withName - Sets the `name` property of the internal
+* state with the provided `PascalCaseString` value.
+*
+* @property {Function} reset - Resets the internal state of the builder to
+* the default `ComponentType` values.
+*
+* @property {Function} build - Validates the internal state of the builder
+* and returns a finalized `ComponentType` object. Throws a `SyntaxError` if
+* validation fails.
+*/
+const getBlueprintComponentTypeBuilder = () => {
+	const internalState = { ...DEFAULT_BLUEPRINT_COMPONENT_TYPE };
+	const builder = {
+		withInfrastructureDomain: (domain) => {
+			internalState.domain = domain;
+			return builder;
+		},
+		withServiceDeliveryModel: (serviceDeliveryModel) => {
+			internalState.serviceDeliveryModel = serviceDeliveryModel;
+			return builder;
+		},
+		withName: (name) => {
+			internalState.name = name;
+			return builder;
+		},
+		reset: () => {
+			internalState.domain = DEFAULT_BLUEPRINT_COMPONENT_TYPE.domain;
+			internalState.serviceDeliveryModel = DEFAULT_BLUEPRINT_COMPONENT_TYPE.serviceDeliveryModel;
+			internalState.name = DEFAULT_BLUEPRINT_COMPONENT_TYPE.name;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidBlueprintComponentType(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return {
+				...internalState,
+				toString: () => `${internalState.domain}.${internalState.serviceDeliveryModel}.${internalState.name}`
+			};
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/values/generic_parameters.ts
+/**
+* Provides a mechanism to manage and retrieve named fields from an internal container.
+*
+* This function returns an object with methods to access required and optional fields by name.
+* It utilizes an internal container to store field data, enabling controlled retrieval of fields.
+*
+* @returns {GenericParameters} An object containing methods for field retrieval:
+*   - `getRequiredFieldByName`: Retrieves a specified field by name. Throws an error if the field is not defined.
+*   - `getOptionalFieldByName`: Retrieves a specified field by name. Returns null if the field is not defined.
+*/
+const getParametersInstance = () => {
+	const container = {};
+	return {
+		getRequiredFieldByName: (name) => {
+			if (typeof container[name] === "undefined" || container[name] === null) throw new Error(`Required field ${name} is not defined`);
+			return container[name];
+		},
+		getOptionalFieldByName: (name) => container[name] ?? null,
+		getAllFieldNames: () => Object.keys(container),
+		push: (key, value) => container[key] = value,
+		remove: (key) => delete container[key],
+		toMap: () => ({ ...container })
+	};
+};
+
+//#endregion
+//#region src/component/id.ts
+/**
+* Validates whether the given identifier is in a valid kebab-case format.
+*
+* @param {ComponentId} id - The identifier object to validate, containing the value to check.
+* @returns {boolean} - Returns true if the identifier is in a valid kebab-case format, false otherwise.
+*/
+const isValidId = (id) => {
+	return isValidKebabCaseString(id.value.toString()).map((x) => `[Component Id: ${id.value.toString()}]${x}`);
+};
+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$1(DEFAULT_COMPONENT_ID, other),
+	toString: () => ""
+};
+/**
+* Creates and returns a builder for constructing a `ComponentId` object.
+*
+* The builder provides methods to set properties of the `ComponentId`, reset them to default
+* values, and validate and build the final object. The `build` method performs validation before
+* creating the `ComponentId`, and throws an error if any validation rules are violated.
+*
+* @returns {ComponentIdBuilder} A builder with methods to configure and build a `ComponentId`.
+*/
+const getComponentIdBuilder = () => {
+	const internalState = { ...DEFAULT_COMPONENT_ID };
+	const builder = {
+		withValue: (value) => {
+			internalState.value = value;
+			return builder;
+		},
+		reset: () => {
+			internalState.value = DEFAULT_COMPONENT_ID.value;
+			internalState.equals = DEFAULT_COMPONENT_ID.equals;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidId(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			const builtId = {
+				...internalState,
+				equals: (other) => equals$1(builtId, other),
+				toString: () => builtId.value.toString()
+			};
+			return builtId;
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/component/link.ts
+/**
+* A function to determine if a given ComponentLink is valid.
+*
+* This function checks the validity of a ComponentLink object by verifying
+* the validity of its `id` and `type` properties.
+*
+* @param {ComponentLink} link - The ComponentLink object to validate.
+* @returns {boolean} - Returns true if the link's `id` is valid and its `type` is valid; otherwise, returns false.
+*/
+const isValidLink = (link) => {
+	const idErrors = isValidId(link.id);
+	const typeErrors = isValidComponentType(link.type);
+	return [...idErrors.map((x) => `[Link: ${link.id.value}] Id error: ${x}`), ...typeErrors.map((x) => `[Link: ${link.id.value}] Type error: ${x}`)];
+};
+const DEFAULT_LINK = {
+	id: DEFAULT_COMPONENT_ID,
+	type: DEFAULT_COMPONENT_TYPE,
+	parameters: getParametersInstance()
+};
+/**
+* Creates and returns a builder for constructing `ComponentLink` objects.
+*
+* The `getLinkBuilder` function provides a fluent interface for configuring a `ComponentLink` instance.
+* It allows setting properties such as `id`, `type`, and `parameters`. The builder maintains an internal
+* state to incrementally configure the `ComponentLink` object.
+*
+* Functions exposed by the builder:
+*
+* - `withId(id: ComponentId): LinkBuilder`: Assigns the provided `id` to the `ComponentLink`.
+* - `withType(type: ComponentType): LinkBuilder`: Assigns the provided `type` to the `ComponentLink`.
+* - `withParameters(parameters: LinkParameters): LinkBuilder`: Assigns the provided `parameters` to the `ComponentLink`.
+* - `reset(): LinkBuilder`: Resets the builder state to its default values.
+* - `build(): ComponentLink`: Validates the internal state and constructs an immutable `ComponentLink` instance.
+*
+* Throws:
+* - `SyntaxError` if the internal state is invalid when invoking `build()`.
+*
+* @returns {LinkBuilder} The builder object to configure and construct `ComponentLink` instances.
+*/
+const getLinkBuilder = () => {
+	const internalState = { ...DEFAULT_LINK };
+	const builder = {
+		withId: (id) => {
+			internalState.id = id;
+			return builder;
+		},
+		withType: (type) => {
+			internalState.type = type;
+			return builder;
+		},
+		withParameters: (parameters) => {
+			internalState.parameters = parameters;
+			return builder;
+		},
+		reset: () => {
+			internalState.id = DEFAULT_LINK.id;
+			internalState.type = DEFAULT_LINK.type;
+			internalState.parameters = DEFAULT_LINK.parameters;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidLink(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return { ...internalState };
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/values/helpers.ts
+const isNonEmptyString = (value) => typeof value === "string" && value.trim() !== "";
+
+//#endregion
+//#region src/component/entity.ts
+/**
+* Represents the default configuration for a component within the system.
+* This constant can be used as a template or fallback value when no specific component configuration is available.
+*
+* Properties of this constant include:
+* - `type`: The default component type identifier.
+* - `id`: The unique identifier for the default component.
+* - `version`: The version of the default component.
+* - `displayName`: An empty string representing a placeholder for the display name.
+* - `description`: An empty string serving as a placeholder for the component description.
+* - `parameters`: Default parameters for the component, retrieved from a predefined instance.
+* - `outputFields`: The default output fields structure with a nested empty object under `value`.
+* - `links`: An empty array indicating no predefined links for the default configuration.
+* - `dependencies`: An empty array representing no external dependencies.
+*/
+const DEFAULT_COMPONENT = {
+	type: DEFAULT_COMPONENT_TYPE,
+	id: DEFAULT_COMPONENT_ID,
+	version: DEFAULT_VERSION,
+	displayName: "",
+	description: "",
+	parameters: getParametersInstance(),
+	outputFields: { value: {} },
+	links: [],
+	dependencies: []
+};
+/**
+* Validates a given component object and returns a list of error messages if any validations fail.
+*
+* The function checks the following properties of the `component`:
+* - `id`: Assessed using the `isValidId` function.
+* - `type`: Assessed using the `isValidComponentType` function.
+* - `version`: Assessed using the `isValidVersion` function.
+* - `displayName`: Validated to ensure it is a non-empty string.
+*
+* Validation errors are returned as strings formatted with the component's ID for easy identification.
+*
+* @param {Component} component - The component object to validate. Must include the fields `id`, `type`, `version`, and `displayName`.
+* @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 = 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,
+		...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.
+*
+* The `getComponentBuilder` function provides a fluent interface for configuring a `Component` instance.
+* It allows setting properties such as `type`, `id`, `version`, `displayName`, `description`, `parameters`,
+* `links`, and `dependencies`. The builder maintains an internal state to incrementally configure the `Component` object.
+*
+* Functions exposed by the builder:
+*
+* - `withType(type: ComponentType): ComponentBuilder`: Assigns the provided `type` to the `Component`.
+* - `withId(id: ComponentId): ComponentBuilder`: Assigns the provided `id` to the `Component`.
+* - `withVersion(version: Version): ComponentBuilder`: Assigns the provided `version` to the `Component`.
+* - `withDisplayName(displayName: string): ComponentBuilder`: Assigns the provided `displayName` to the `Component`.
+* - `withDescription(description: string): ComponentBuilder`: Assigns the provided `description` to the `Component`.
+* - `withParameters(parameters: ComponentParameters): ComponentBuilder`: Assigns the provided `parameters` to the `Component`.
+* - `withLinks(links: ComponentLink[]): ComponentBuilder`: Assigns the provided `links` to the `Component`.
+* - `withDependencies(dependencies: Dependency[]): ComponentBuilder`: Assigns the provided `dependencies` to the `Component`.
+* - `reset(): ComponentBuilder`: Resets the builder state to its default values.
+* - `build(): Component`: Validates the internal state and constructs an immutable `Component` instance.
+*
+* Throws:
+* - `SyntaxError` if the internal state is invalid when invoking `build()`.
+*
+* @returns {ComponentBuilder} The builder object to configure and construct `Component` instances.
+*/
+const getComponentBuilder = () => {
+	const internalState = { ...DEFAULT_COMPONENT };
+	const builder = {
+		withType: (type) => {
+			internalState.type = type;
+			return builder;
+		},
+		withId: (id) => {
+			internalState.id = id;
+			return builder;
+		},
+		withVersion: (version) => {
+			internalState.version = version;
+			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_COMPONENT.type;
+			internalState.id = DEFAULT_COMPONENT.id;
+			internalState.version = DEFAULT_COMPONENT.version;
+			internalState.displayName = DEFAULT_COMPONENT.displayName;
+			internalState.description = DEFAULT_COMPONENT.description;
+			internalState.parameters = DEFAULT_COMPONENT.parameters;
+			internalState.links = DEFAULT_COMPONENT.links;
+			internalState.dependencies = DEFAULT_COMPONENT.dependencies;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidComponent(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return { ...internalState };
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/component/index.ts
+let Component;
+(function(_Component) {
+	let Type;
+	(function(_Type) {
+		_Type.getBuilder = getComponentTypeBuilder;
+	})(Type || (Type = _Component.Type || (_Component.Type = {})));
+	let Parameters;
+	(function(_Parameters) {
+		_Parameters.getInstance = getParametersInstance;
+	})(Parameters || (Parameters = _Component.Parameters || (_Component.Parameters = {})));
+	let Link;
+	(function(_Link) {
+		let Parameters;
+		(function(_Parameters2) {
+			_Parameters2.getInstance = getParametersInstance;
+		})(Parameters || (Parameters = _Link.Parameters || (_Link.Parameters = {})));
+		_Link.getBuilder = getLinkBuilder;
+	})(Link || (Link = _Component.Link || (_Component.Link = {})));
+	let Id;
+	(function(_Id) {
+		_Id.getBuilder = getComponentIdBuilder;
+	})(Id || (Id = _Component.Id || (_Component.Id = {})));
+	_Component.getBuilder = getComponentBuilder;
+})(Component || (Component = {}));
+
+//#endregion
+//#region src/fractal/component/entity.ts
+const DEFAULT_BLUEPRINT_COMPONENT = {
+	...DEFAULT_COMPONENT,
+	type: DEFAULT_BLUEPRINT_COMPONENT_TYPE,
+	dependencies: [],
+	isLocked: false,
+	recreateOnFailure: false
+};
+const isValidBlueprintComponent = (component) => {
+	return isValidComponent({
+		...component,
+		dependencies: []
+	});
+};
+/**
+* Creates and returns a builder for constructing `BlueprintComponent` instances.
+*
+* The builder provides a fluent API for setting various properties of a `BlueprintComponent`
+* and performs validation upon calling the `build` method to ensure the resulting object
+* is valid. If validation fails, an error is thrown.
+*
+* @returns {BlueprintComponentBuilder} An object with methods to configure and build a `BlueprintComponent`.
+*
+* Methods available on the builder:
+* - `withType(type: BlueprintComponentType)`: Sets the type of the component.
+* - `withId(id: ComponentId)`: Sets the unique identifier for the 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: 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`.
+* - `build()`: Validates and constructs the `BlueprintComponent` object. Throws an error if validation fails.
+*/
+const getBlueprintComponentBuilder = () => {
+	const internalState = { ...DEFAULT_BLUEPRINT_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;
+		},
+		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_BLUEPRINT_COMPONENT.type;
+			internalState.id = DEFAULT_BLUEPRINT_COMPONENT.id;
+			internalState.version = DEFAULT_BLUEPRINT_COMPONENT.version;
+			internalState.displayName = DEFAULT_BLUEPRINT_COMPONENT.displayName;
+			internalState.description = DEFAULT_BLUEPRINT_COMPONENT.description;
+			internalState.parameters = DEFAULT_BLUEPRINT_COMPONENT.parameters;
+			internalState.links = DEFAULT_BLUEPRINT_COMPONENT.links;
+			internalState.dependencies = DEFAULT_BLUEPRINT_COMPONENT.dependencies;
+			internalState.isLocked = DEFAULT_BLUEPRINT_COMPONENT.isLocked;
+			internalState.recreateOnFailure = DEFAULT_BLUEPRINT_COMPONENT.recreateOnFailure;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidBlueprintComponent(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return { ...internalState };
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/fractal/component/index.ts
+let BlueprintComponent;
+(function(_BlueprintComponent) {
+	let Type;
+	(function(_Type) {
+		_Type.getBuilder = getBlueprintComponentTypeBuilder;
+	})(Type || (Type = _BlueprintComponent.Type || (_BlueprintComponent.Type = {})));
+	let Id;
+	(function(_Id) {
+		_Id.getBuilder = Component.Id.getBuilder;
+	})(Id || (Id = _BlueprintComponent.Id || (_BlueprintComponent.Id = {})));
+	_BlueprintComponent.getBuilder = getBlueprintComponentBuilder;
+})(BlueprintComponent || (BlueprintComponent = {}));
+
+//#endregion
+//#region src/fractal/service.ts
+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) => {
+	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.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: Object.keys(c.outputFields.value)
+		}))
+	}).catch((e) => console.error(e.message, e.response.text));
+};
+const destroyFractal = async (credentials, id) => {
+	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) {
+	_FractalService.deploy = deployFractal;
+	_FractalService.destroy = destroyFractal;
+})(FractalService || (FractalService = {}));
+
+//#endregion
+//#region src/fractal/entity.ts
+/**
+* Represents the default configuration for a fractal object.
+* This variable initializes a fractal with predefined values and
+* provides default methods for deployment and destruction.
+*
+* @constant {Fractal} DEFAULT_FRACTAL
+* @property {string} id - The unique identifier of the fractal.
+* @property {boolean} isPrivate - Determines if the fractal is private.
+* @property {string} description - A brief description of the fractal.
+* @property {Array} components - A collection of components associated with the fractal.
+* @property {function} deploy - A method to deploy the fractal.
+* @property {function} destroy - A method to clean up or destroy the fractal.
+*/
+const DEFAULT_FRACTAL = {
+	id: DEFAULT_FRACTAL_ID,
+	isPrivate: false,
+	description: "",
+	components: [],
+	deploy: () => Promise.reject(),
+	destroy: () => Promise.reject()
+};
+/**
+* Validates a given fractal object and returns a list of error messages if any issues are found.
+*
+* This function checks the following:
+* 1. Validity of the fractal's ID through the `isValidFractalId` function.
+* 2. Presence and validity of the fractal's components through the `isValidBlueprintComponent` function.
+*
+* If the fractal has:
+* - An invalid ID: Any errors related to the ID are added to the error list.
+* - No components or an empty components array: Adds an error indicating components must not be empty.
+* - Invalid components: Errors from validating each component are appended to the error list.
+*
+* @param {Fractal} fractal - The fractal object to validate. Must include an ID and an array of components.
+* @returns {string[]} An array of error messages describing any validation issues with the 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));
+		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 = {
+		withId: (value) => {
+			internalState.id = value;
+			return builder;
+		},
+		withIsPrivate: (value) => {
+			internalState.isPrivate = 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;
+		},
+		reset: () => {
+			internalState.id = DEFAULT_FRACTAL.id;
+			internalState.isPrivate = DEFAULT_FRACTAL.isPrivate;
+			internalState.description = DEFAULT_FRACTAL.description;
+			internalState.components = DEFAULT_FRACTAL.components;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidFractal(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return {
+				...internalState,
+				deploy: (credentials) => FractalService.deploy(credentials, internalState),
+				destroy: (credentials) => FractalService.destroy(credentials, internalState.id)
+			};
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/fractal/index.ts
+let Fractal$1;
+(function(_Fractal) {
+	let Id;
+	(function(_Id) {
+		_Id.getBuilder = getFractalIdBuilder;
+	})(Id || (Id = _Fractal.Id || (_Fractal.Id = {})));
+	let Component;
+	(function(_Component) {
+		_Component.getBuilder = getBlueprintComponentBuilder;
+		let Type;
+		(function(_Type) {
+			_Type.getBuilder = getBlueprintComponentTypeBuilder;
+		})(Type || (Type = _Component.Type || (_Component.Type = {})));
+		let Id;
+		(function(_Id2) {
+			_Id2.getBuilder = BlueprintComponent.Id.getBuilder;
+		})(Id || (Id = _Component.Id || (_Component.Id = {})));
+	})(Component || (Component = _Fractal.Component || (_Fractal.Component = {})));
+	_Fractal.getBuilder = getFractalBuilder;
+})(Fractal$1 || (Fractal$1 = {}));
+
+//#endregion
+//#region src/bounded_context/entity.ts
+const DEFAULT = {
+	id: DEFAULT_BOUNDED_CONTEXT_ID,
+	displayName: ""
+};
+/**
+* Determines whether the given bounded context object is valid.
+*
+* The validation checks if the bounded context contains:
+* - A valid bounded context ID, verified through the `isValidBoundedContextId` function.
+* - A non-empty string as the display name, verified through the `isNonEmptyString` function.
+*
+* @param {BoundedContext} value - The bounded context object to be validated.
+* @returns {boolean} Returns true if the bounded context is valid; otherwise, returns false.
+*/
+const isValidBoundedContext = (value) => {
+	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.
+*
+* The `getBoundedContextBuilder` function returns an object with methods that allow incremental construction
+* of a `BoundedContext` instance. It ensures validation at the `build()` step and supports resets
+* to default values.
+*
+* @function
+* @returns {BoundedContextBuilder} A builder object for creating a `BoundedContext` instance.
+*
+* @throws {SyntaxError} Thrown when attempting to build a `BoundedContext` instance
+* that is invalid, such as when required fields are not initialized.
+*/
+const getBoundedContextBuilder = () => {
+	const internalState = { ...DEFAULT };
+	const builder = {
+		withId: (id) => {
+			internalState.id = id;
+			return builder;
+		},
+		withDisplayName: (displayName) => {
+			internalState.displayName = displayName;
+			return builder;
+		},
+		withDescription: (description) => {
+			internalState.description = description;
+			return builder;
+		},
+		reset: () => {
+			internalState.id = DEFAULT.id;
+			internalState.displayName = DEFAULT.displayName;
+			internalState.description = DEFAULT.description;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidBoundedContext(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return { ...internalState };
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/bounded_context/index.ts
+let BoundedContext$1;
+(function(_BoundedContext) {
+	let Id;
+	(function(_Id) {
+		_Id.getBuilder = getBoundedContextIdBuilder;
+	})(Id || (Id = _BoundedContext.Id || (_BoundedContext.Id = {})));
+	_BoundedContext.getBuilder = getBoundedContextBuilder;
+})(BoundedContext$1 || (BoundedContext$1 = {}));
+
+//#endregion
+//#region src/values/service_account_id.ts
+/**
+* Represents the default service account identifier used in the application.
+* This value is typically utilized to associate operations or resources with the
+* default service account when no specific account is provided.
+*
+* @constant {ServiceAccountId}
+*/
+const DEFAULT_SERVICE_ACCOUNT_ID = { serviceAccountIdValue: "" };
+/**
+* Validates whether the provided value is a valid service account ID.
+*
+* The function determines validity by checking if the given value is a valid UUID.
+* It returns an array of validation error messages if the value is invalid;
+* otherwise, it returns an empty array.
+*
+* @param {string} value - The value to be validated as a service account ID.
+* @returns {string[]} An array of validation errors, or an empty array if valid.
+*/
+const isValidServiceAccountId = (value) => {
+	if (!value || !value.serviceAccountIdValue) return ["Value must be a non-empty string"];
+	return isValidUuid(value.serviceAccountIdValue);
+};
+/**
+* Creates and returns a builder object for constructing a ServiceAccountId.
+*
+* The builder provides methods to configure and build a ServiceAccountId, ensuring
+* that the resulting object adheres to the required validation rules.
+*
+* @returns {ServiceAccountIdBuilder} A builder instance used to configure and construct
+* a ServiceAccountId object.
+*
+* The builder provides the following functionalities:
+* - `withValue(value: string)`: Sets the `value` for the ServiceAccountId. The provided
+*   value must be a valid UUID; otherwise, a `RangeError` is thrown.
+* - `reset()`: Resets the `value` to the default value specified by `DEFAULT_SERVICE_ACCOUNT_ID`.
+* - `build()`: Constructs the ServiceAccountId object. If the current state contains
+*   validation errors, a `SyntaxError` is thrown with the list of validation messages.
+*
+* The builder maintains an internal mutable state that is used to apply configurations
+* incrementally until `build()` is called to produce the final ServiceAccountId object.
+*/
+const getServiceAccountIdBuilder = () => {
+	const internalState = { ...DEFAULT_SERVICE_ACCOUNT_ID };
+	const builder = {
+		withValue: (value) => {
+			internalState.serviceAccountIdValue = value;
+			return builder;
+		},
+		reset: () => {
+			internalState.serviceAccountIdValue = DEFAULT_SERVICE_ACCOUNT_ID.serviceAccountIdValue;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidServiceAccountId(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return { ...internalState };
+		}
+	};
+	return builder;
+};
+let ServiceAccountId$1;
+(function(_ServiceAccountId) {
+	_ServiceAccountId.getBuilder = getServiceAccountIdBuilder;
+})(ServiceAccountId$1 || (ServiceAccountId$1 = {}));
+
+//#endregion
+//#region src/values/service_account_credentials.ts
+const DEFAULT_SERVICE_ACCOUNT_CREDENTIALS = {
+	id: DEFAULT_SERVICE_ACCOUNT_ID,
+	secret: ""
+};
+/**
+* Validates the provided service account credentials and returns a list of validation errors.
+*
+* @param {ServiceAccountCredentials} value - The service account credentials to validate.
+* @returns {string[]} - An array of error messages, where each message describes a validation issue.
+*                       If the credentials are valid, the array is empty.
+*/
+const isValidServiceAccountCredentials = (value) => {
+	const idErrors = isValidServiceAccountId(value.id);
+	const secretErrors = value.secret ? [] : ["Secret must be a non-empty string"];
+	return [...idErrors, ...secretErrors];
+};
+/**
+* Creates and returns a builder for constructing service account credentials.
+*
+* The builder provides methods to configure and validate a `ServiceAccountCredentials` object.
+* It includes support for setting the `id` and `secret`, resetting to default values,
+* and finalizing the construction by ensuring the credentials are valid.
+*
+* @returns {ServiceAccountCredentialsBuilder} A builder object to construct `ServiceAccountCredentials`.
+*/
+const getServiceAccountCredentialsBuilder = () => {
+	const internalState = { ...DEFAULT_SERVICE_ACCOUNT_CREDENTIALS };
+	const builder = {
+		withId: (value) => {
+			internalState.id = value;
+			return builder;
+		},
+		withSecret: (value) => {
+			internalState.secret = value;
+			return builder;
+		},
+		reset: () => {
+			internalState.id = DEFAULT_SERVICE_ACCOUNT_CREDENTIALS.id;
+			internalState.secret = DEFAULT_SERVICE_ACCOUNT_CREDENTIALS.secret;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidServiceAccountCredentials(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return { ...internalState };
+		}
+	};
+	return builder;
+};
+let ServiceAccountCredentials$1;
+(function(_ServiceAccountCredentials) {
+	_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;
+const Fractal = Fractal$1;
+const InfrastructureDomain = InfrastructureDomain$1;
+const KebabCaseString = KebabCaseString$1;
+const OwnerId = OwnerId$1;
+const OwnerType = OwnerType$1;
+const PascalCaseString = PascalCaseString$1;
+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, Environment, Fractal, InfrastructureDomain, KebabCaseString, LiveSystem, OwnerId, OwnerType, PascalCaseString, ServiceAccountCredentials, ServiceAccountId, ServiceDeliveryModel, Version };