@fractal_cloud/sdk 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,1493 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let superagent = require("superagent");
+superagent = __toESM(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 = { kebabValue: "" };
+/**
+* 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 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.kebabValue = value;
+			return builder;
+		},
+		reset: () => {
+			internalState.kebabValue = DEFAULT_KEBAB_CASE_STRING.kebabValue;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidKebabCaseString(internalState.kebabValue);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return { ...internalState };
+		}
+	};
+	return builder;
+};
+let KebabCaseString$1;
+(function(_KebabCaseString) {
+	_KebabCaseString.getBuilder = getKebabCaseStringBuilder;
+})(KebabCaseString$1 || (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}`;
+/**
+* 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$2(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$2(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$2(builtVersion, other),
+				toString: () => toString$1(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 = { ownerIdValue: "" };
+/**
+* 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.ownerIdValue) return ["Value must be a non-empty string"];
+	return isValidUuid(value.ownerIdValue);
+};
+/**
+* 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.ownerIdValue = value;
+			return builder;
+		},
+		reset: () => {
+			internalState.ownerIdValue = DEFAULT_OWNER_ID.ownerIdValue;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidOwnerId(internalState);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return { ...internalState };
+		}
+	};
+	return builder;
+};
+let OwnerId$1;
+(function(_OwnerId) {
+	_OwnerId.getBuilder = getOwnerIdBuilder;
+})(OwnerId$1 || (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;
+/**
+* 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 = {
+	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)
+};
+/**
+* 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 = 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 boundedContextIdToString = (id) => `${id.ownerType.toString()}/${id.ownerId.ownerIdValue}/${id.name.kebabValue}`;
+/**
+* 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$1(builtId, other),
+				toString: () => boundedContextIdToString(builtId)
+			};
+			return builtId;
+		}
+	};
+	return builder;
+};
+
+//#endregion
+//#region src/fractal/id.ts
+const toString = (id) => `${id.boundedContextId.toString()}/${id.name.kebabValue}:${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 = isValidBoundedContextId(id.boundedContextId);
+	const nameErrors = isValidKebabCaseString(id.name.kebabValue);
+	const versionErrors = 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}`)
+	];
+};
+/**
+* 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
+};
+/**
+* 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,
+				toString: () => toString(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 = { pascalValue: "" };
+/**
+* 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.pascalValue = value;
+			return builder;
+		},
+		reset: () => {
+			internalState.pascalValue = DEFAULT_PASCAL_CASE_STRING.pascalValue;
+			return builder;
+		},
+		build: () => {
+			const validationErrors = isValidPascalCaseString(internalState.pascalValue);
+			if (validationErrors.length > 0) throw new SyntaxError(validationErrors.join("\n"));
+			return { ...internalState };
+		}
+	};
+	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.pascalValue);
+	if (nameError.length > 0) return nameError.map((x) => `[Component Type: ${type.name.pascalValue}] Name error: ${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 };
+		}
+	};
+	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.kebabValue).map((x) => `[Component Id: ${id.value.kebabValue}] Id error: ${x}`);
+};
+const equals = (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)
+};
+/**
+* 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(builtId, other)
+			};
+			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 = 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"];
+	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}`)
+	];
+};
+/**
+* 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: GenericParameters)`: 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 = "X-ClientID";
+const CLIENT_SECRET_HEADER = "X-ClientSecret";
+const FRACTAL_API_URL = "https://api.fractal.cloud";
+const deployFractal = async (credentials, fractal) => {
+	await superagent.default.post(`${FRACTAL_API_URL}/blueprints/${fractal.id.toString().replace(":", "/")}`).set(CLIENT_ID_HEADER, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER, credentials.secret).send({
+		description: fractal.description,
+		isPrivate: fractal.isPrivate,
+		components: fractal.components.map((c) => ({
+			...c,
+			type: c.type.toString(),
+			id: c.id.value.kebabValue,
+			version: c.version.toString(),
+			parameters: c.parameters.toMap(),
+			dependencies: c.dependencies.map((d) => d.id.value.kebabValue),
+			links: c.links.map((l) => ({
+				componentId: l.id.value.kebabValue,
+				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.default.delete(`${FRACTAL_API_URL}/blueprints/${id.toString().replace(":", "/")}`).set(CLIENT_ID_HEADER, credentials.id.serviceAccountIdValue).set(CLIENT_SECRET_HEADER, 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 = 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) => {
+		acc.push(...isValidBlueprintComponent(x));
+		return acc;
+	}, []);
+	return [...idErrors, ...componentsErrors];
+};
+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 = 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}`)];
+};
+/**
+* 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/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;
+
+//#endregion
+exports.BoundedContext = BoundedContext;
+exports.Fractal = Fractal;
+exports.InfrastructureDomain = InfrastructureDomain;
+exports.KebabCaseString = KebabCaseString;
+exports.OwnerId = OwnerId;
+exports.OwnerType = OwnerType;
+exports.PascalCaseString = PascalCaseString;
+exports.ServiceAccountCredentials = ServiceAccountCredentials;
+exports.ServiceAccountId = ServiceAccountId;
+exports.ServiceDeliveryModel = ServiceDeliveryModel;
+exports.Version = Version;