@fractal_cloud/sdk 0.1.1 → 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,1625 @@
+//#region src/values/kebab_case_string.d.ts
+/**
+ * Represents a string formatted in kebab-case.
+ * Kebab-case is a naming convention where words are
+ * concatenated together, separated by hyphens, and all
+ * characters are in lowercase.
+ *
+ * This type enforces the structure of a string that adheres
+ * to the kebab-case standard. It is typically used in contexts
+ * where consistent, hyphen-delimited identifiers are required.
+ */
+type KebabCaseString$1 = {
+  _type: 'kebab';
+  value: string;
+  equals: (other: KebabCaseString$1) => boolean;
+  toString: () => string;
+};
+/**
+ * Builder interface for constructing KebabCaseString objects.
+ * Provides a fluent API for setting and validating Kebab case strings.
+ */
+type KebabCaseStringBuilder = {
+  /**
+   * Sets the value of the KebabCaseString.
+   * @param value - The string value in Kebab case format
+   * @returns The builder instance for method chaining
+   * @throws {RangeError} If the input is not in Kebab case format
+   */
+  withValue: (value: string) => KebabCaseStringBuilder;
+  /**
+   * Resets the builder to its default state, clearing the current value.
+   * @returns The builder instance for method chaining
+   */
+  reset: () => KebabCaseStringBuilder;
+  /**
+   * Constructs and returns the final KebabCaseString object.
+   * @returns The constructed KebabCaseString object
+   * @throws {SyntaxError} If no value has been set before building
+   */
+  build: () => KebabCaseString$1;
+};
+declare namespace KebabCaseString$1 {
+  const getBuilder: () => KebabCaseStringBuilder;
+}
+//#endregion
+//#region src/component/id.d.ts
+/**
+ * Represents a unique identifier for a component, adhering to a kebab-case format.
+ * Provides functionality to compare two ComponentId instances for equality.
+ *
+ * @typedef {Object} ComponentId
+ * @property {KebabCaseString} value - The string representation of the component identifier in kebab-case format.
+ * @property {function(ComponentId): boolean} equals - A method to check if the given ComponentId is equal to the current instance.
+ */
+type ComponentId = {
+  value: KebabCaseString$1;
+  equals: (other: ComponentId) => boolean;
+  toString: () => string;
+};
+/**
+ * Builder interface for constructing ComponentId instances.
+ *
+ * The builder follows a fluent API pattern, allowing method chaining to configure
+ * the component identifier before building the final instance. It validates the
+ * component ID upon build and throws a SyntaxError if validation fails.
+ *
+ * @example
+ * ```typescript
+ * const componentId = getComponentIdBuilder()
+ *   .withValue(someKebabCaseString)
+ *   .build();
+ * ```
+ */
+type ComponentIdBuilder = {
+  /**
+   * Sets the kebab-case string value for the component identifier.
+   *
+   * @param {KebabCaseString} value - The kebab-case string value to use for the component ID.
+   * @returns {ComponentIdBuilder} The builder instance for method chaining.
+   */
+  withValue: (value: KebabCaseString$1) => ComponentIdBuilder;
+  /**
+   * Resets the builder to its default state, clearing all configured values.
+   *
+   * @returns {ComponentIdBuilder} The builder instance for method chaining.
+   */
+  reset: () => ComponentIdBuilder;
+  /**
+   * Constructs and validates the ComponentId instance.
+   *
+   * @returns {ComponentId} The constructed and validated component identifier.
+   * @throws {SyntaxError} If the component ID fails validation.
+   */
+  build: () => ComponentId;
+};
+//#endregion
+//#region src/values/owner_type.d.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.
+ */
+declare enum OwnerType$1 {
+  Personal = "Personal",
+  Organizational = "Organizational"
+}
+//#endregion
+//#region src/values/owner_id.d.ts
+/**
+ * Represents a string that adheres to the OwnerId naming convention.
+ * This convention capitalizes the first letter of each concatenated word without any spaces, dashes, or underscores.
+ */
+type OwnerId$1 = {
+  _type: 'ownerId';
+  value: string;
+  toString: () => string;
+};
+/**
+ * Builder interface for constructing OwnerId objects.
+ * Provides a fluent API for setting and validating uuid strings.
+ */
+type OwnerIdBuilder = {
+  /**
+   * Sets the value of the OwnerId.
+   * @param value - The string value in uuid format
+   * @returns The builder instance for method chaining
+   * @throws {RangeError} If the input is not in uuid case format
+   */
+  withValue: (value: string) => OwnerIdBuilder;
+  /**
+   * Resets the builder to its default state, clearing the current value.
+   * @returns The builder instance for method chaining
+   */
+  reset: () => OwnerIdBuilder;
+  /**
+   * Constructs and returns the final OwnerId object.
+   * @returns The constructed OwnerId object
+   * @throws {SyntaxError} If no value has been set before building
+   */
+  build: () => OwnerId$1;
+};
+declare namespace OwnerId$1 {
+  const getBuilder: () => OwnerIdBuilder;
+}
+//#endregion
+//#region src/bounded_context/id.d.ts
+/**
+ * Represents the unique identifier for a bounded context.
+ *
+ * A bounded context is a distinct and cohesive domain of responsibility
+ * within a larger distributed system or domain, and this type
+ * provides the necessary information to identify it.
+ *
+ * @typedef {Object} BoundedContextId
+ *
+ * @property {OwnerType} ownerType - The type of the owner associated with the bounded context.
+ * @property {OwnerId} ownerId - The unique identifier of the owner.
+ * @property {KebabCaseString} name - The name of the bounded context, formatted as a kebab-case string.
+ */
+type BoundedContextId = {
+  _type: 'bounded_context';
+  ownerType: OwnerType$1;
+  ownerId: OwnerId$1;
+  name: KebabCaseString$1;
+  equals: (other: BoundedContextId) => boolean;
+  toString: () => string;
+};
+/**
+ * Builder interface for constructing Id objects.
+ * Provides a fluent API for setting and validating bounded context identifiers.
+ */
+type BoundedContextIdBuilder = {
+  /**
+   * Sets the owner type of the Id.
+   * @param ownerType - The type of the owner (e.g., Personal, Organization)
+   * @returns The builder instance for method chaining
+   */
+  withOwnerType: (ownerType: OwnerType$1) => BoundedContextIdBuilder;
+  /**
+   * Sets the owner ID of the Id.
+   * @param ownerId - The unique identifier of the owner
+   * @returns The builder instance for method chaining
+   */
+  withOwnerId: (ownerId: OwnerId$1) => BoundedContextIdBuilder;
+  /**
+   * Sets the name of the Id.
+   * @param name - The name in kebab-case format
+   * @returns The builder instance for method chaining
+   */
+  withName: (name: KebabCaseString$1) => BoundedContextIdBuilder;
+  /**
+   * Resets the builder to its default state, restoring all default values.
+   * @returns The builder instance for method chaining
+   */
+  reset: () => BoundedContextIdBuilder;
+  /**
+   * Constructs and returns the final Id object.
+   * @returns The constructed Id object
+   * @throws {SyntaxError} If the resulting Id is invalid
+   */
+  build: () => BoundedContextId;
+};
+//#endregion
+//#region src/bounded_context/entity.d.ts
+/**
+ * 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.
+ */
+/**
+ * Builder interface for constructing BoundedContext objects.
+ * Provides a fluent API for setting and validating bounded context properties.
+ */
+type BoundedContextBuilder = {
+  /**
+   * Sets the ID of the BoundedContext.
+   * @param id - The unique identifier for the bounded context
+   * @returns The builder instance for method chaining
+   */
+  withId: (id: BoundedContextId) => BoundedContextBuilder;
+  /**
+   * Sets the display name of the BoundedContext.
+   * @param displayName - The human-readable name for the bounded context
+   * @returns The builder instance for method chaining
+   */
+  withDisplayName: (displayName: string) => BoundedContextBuilder;
+  /**
+   * Sets the description of the BoundedContext.
+   * @param description - An optional description providing additional details about the bounded context's purpose or scope
+   * @returns The builder instance for method chaining
+   */
+  withDescription: (description: string) => BoundedContextBuilder;
+  /**
+   * Resets the builder to its default state, clearing all current values.
+   * @returns The builder instance for method chaining
+   */
+  reset: () => BoundedContextBuilder;
+  /**
+   * Constructs and returns the final BoundedContext object.
+   * @returns The constructed BoundedContext object
+   * @throws {SyntaxError} If the bounded context is invalid (e.g., missing required fields)
+   */
+  build: () => BoundedContext$1;
+};
+//#endregion
+//#region src/bounded_context/index.d.ts
+declare namespace BoundedContext$1 {
+  type Id = BoundedContextId;
+  namespace Id {
+    type Builder = BoundedContextIdBuilder;
+    const getBuilder: () => BoundedContextIdBuilder;
+  }
+  type Builder = BoundedContextBuilder;
+  const getBuilder: () => BoundedContextBuilder;
+}
+/**
+ * A Bounded Context in Fractal Cloud is the mechanism that:
+ * - Maps infrastructure to business domains
+ * - Defines ownership and access boundaries
+ * - Enables self-service without sacrificing control
+ * - Allows large organizations to scale Fractal usage safely
+ *
+ * @typedef {Object} BoundedContext
+ * @property {BoundedContext.Id} id - A unique identifier for the bounded context.
+ * @property {string} displayName - A human-readable name for the bounded context.
+ * @property {string} [description] - An optional description providing additional details about the bounded context's purpose or scope.
+ */
+type BoundedContext$1 = {
+  id: BoundedContext$1.Id;
+  displayName: string;
+  description?: string;
+};
+//#endregion
+//#region src/values/version.d.ts
+/**
+ * Represents a semantic version following the major.minor.patch format.
+ *
+ * This type is used to define a version number, where:
+ * - `major` indicates the major version, typically incremented for incompatible API changes.
+ * - `minor` indicates the minor version, incremented for backwards-compatible enhancements or features.
+ * - `patch` indicates the patch version, incremented for backwards-compatible bug fixes.
+ */
+type Version$1 = {
+  major: number;
+  minor: number;
+  patch: number;
+  equals: (other: Version$1) => boolean;
+  toString: () => string;
+};
+/**
+ * Builder interface for constructing version objects.
+ * Provides a fluent API for setting version components.
+ */
+type VersionBuilder = {
+  /**
+   * Sets the major version number.
+   * @param major - The major version number
+   * @returns The builder instance for method chaining
+   */
+  withMajor: (major: number) => VersionBuilder;
+  /**
+   * Sets the minor version number.
+   * @param minor - The minor version number
+   * @returns The builder instance for method chaining
+   */
+  withMinor: (minor: number) => VersionBuilder;
+  /**
+   * Sets the patch version number.
+   * @param patch - The patch version number
+   * @returns The builder instance for method chaining
+   */
+  withPatch: (patch: number) => VersionBuilder;
+  /**
+   * Resets the version to default values (0.0.0).
+   * @returns The builder instance for method chaining
+   */
+  reset: () => VersionBuilder;
+  /**
+   * Constructs and returns the final version object.
+   * @returns The constructed Version object
+   * @throws {SyntaxError} If the version is not initialized
+   */
+  build: () => Version$1;
+};
+declare namespace Version$1 {
+  const getBuilder: () => VersionBuilder;
+}
+//#endregion
+//#region src/fractal/id.d.ts
+/**
+ * Represents a unique identifier for a fractal within a system.
+ * The FractalId consists of a bounded context identifier, a name in kebab case,
+ * a version, and a string representation method.
+ *
+ * @typedef {Object} FractalId
+ * @property {BoundedContext.Id} boundedContextId - The identifier for the bounded context to which the fractal belongs.
+ * @property {KebabCaseString} name - The name of the fractal represented in kebab-case format.
+ * @property {Version} version - The version of the fractal.
+ * @property {function(): string} toString - Returns a string representation of the FractalId.
+ */
+type FractalId = {
+  boundedContextId: BoundedContext$1.Id;
+  name: KebabCaseString$1;
+  version: Version$1;
+  equals: (other: FractalId) => boolean;
+  toString: () => string;
+};
+/**
+ * Represents a builder for creating and configuring instances of a FractalId.
+ * This builder follows a fluent API design, enabling chaining of methods
+ * for greater flexibility and readability.
+ */
+type FractalIdBuilder = {
+  /**
+   * Assigns a bounded context identifier to the FractalIdBuilder.
+   *
+   * @param {BoundedContext.Id} value - The unique identifier for the bounded context to be associated.
+   * @returns {FractalIdBuilder} The updated instance of FractalIdBuilder with the specified bounded context ID applied.
+   */
+  withBoundedContextId: (value: BoundedContext$1.Id) => FractalIdBuilder;
+  /**
+   * Assigns a name, in kebab-case format, to the current Fractal ID being constructed.
+   *
+   * @param {KebabCaseString} name - The name to associate with the Fractal ID. Must follow kebab-case formatting.
+   * @returns {FractalIdBuilder} The updated builder instance, allowing for method chaining.
+   */
+  withName: (name: KebabCaseString$1) => FractalIdBuilder;
+  /**
+   * Sets the version information for the FractalIdBuilder instance.
+   *
+   * @param {Version} version - The version to be associated with the Fractal ID.
+   * @returns {FractalIdBuilder} The updated instance of FractalIdBuilder with the specified version.
+   */
+  withVersion: (version: Version$1) => FractalIdBuilder;
+  /**
+   * Resets the state of the current FractalIdBuilder instance to its initial default configuration.
+   * This method is typically used to clear any modifications made and start fresh.
+   *
+   * @returns {FractalIdBuilder} The current instance of FractalIdBuilder for method chaining.
+   */
+  reset: () => FractalIdBuilder;
+  /**
+   * Generates a FractalId object based on the current state or configuration.
+   *
+   * The `build` function serves to construct and return a fully initialized
+   * instance of a FractalId. This function encapsulates the logic needed
+   * to assemble the FractalId, ensuring all necessary components are properly
+   * configured and validated before being returned.
+   *
+   * @returns {FractalId} A fully constructed FractalId object.
+   */
+  build: () => FractalId;
+};
+//#endregion
+//#region src/values/pascal_case_string.d.ts
+/**
+ * Represents a string that adheres to the PascalCase naming convention.
+ * This convention capitalizes the first letter of each concatenated word without any spaces, dashes, or underscores.
+ * Commonly used in naming conventions for programming constructs such as types, classes, or enums.
+ */
+type PascalCaseString$1 = {
+  _type: 'pascal';
+  value: string;
+  equals: (other: PascalCaseString$1) => boolean;
+  toString: () => string;
+};
+/**
+ * Builder interface for constructing PascalCaseString objects.
+ * Provides a fluent API for setting and validating Pascal case strings.
+ */
+type PascalCaseStringBuilder = {
+  /**
+   * Sets the value of the PascalCaseString.
+   * @param value - The string value in Pascal case format
+   * @returns The builder instance for method chaining
+   * @throws {RangeError} If the input is not in Pascal case format
+   */
+  withValue: (value: string) => PascalCaseStringBuilder;
+  /**
+   * Resets the builder to its default state, clearing the current value.
+   * @returns The builder instance for method chaining
+   */
+  reset: () => PascalCaseStringBuilder;
+  /**
+   * Constructs and returns the final PascalCaseString object.
+   * @returns The constructed PascalCaseString object
+   * @throws {SyntaxError} If no value has been set before building
+   */
+  build: () => PascalCaseString$1;
+};
+declare namespace PascalCaseString$1 {
+  const getBuilder: () => PascalCaseStringBuilder;
+}
+//#endregion
+//#region src/values/infrastructure_domain.d.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.
+ */
+declare enum InfrastructureDomain$1 {
+  ApiManagement = "APIManagement",
+  NetworkAndCompute = "NetworkAndCompute",
+  CustomWorkloads = "CustomWorkloads",
+  Messaging = "Messaging",
+  Storage = "Storage",
+  Observability = "Observability",
+  Security = "Security"
+}
+//#endregion
+//#region src/component/type.d.ts
+/**
+ * Describes a component type within a specific infrastructure domain.
+ *
+ * This type represents a blueprint for defining components by associating
+ * a domain category and a specific name in PascalCase format.
+ *
+ * @typedef {Object} ComponentType
+ * @property {InfrastructureDomain} domain - The domain category to which the component belongs.
+ * @property {PascalCaseString} name - The name of the component, formatted using PascalCase.
+ */
+type ComponentType = {
+  domain: InfrastructureDomain$1;
+  name: PascalCaseString$1;
+};
+/**
+ * A builder interface for constructing Type objects in a fluent and type-safe manner.
+ *
+ * The TypeBuilder provides methods to configure a Type's properties step-by-step,
+ * validate the configuration, and produce an immutable Type instance. It follows
+ * the builder pattern, allowing method chaining for a more readable API.
+ *
+ * @typedef {Object} ComponentTypeBuilder
+ */
+type ComponentTypeBuilder = {
+  /**
+   * Sets the infrastructure domain for the type being built.
+   *
+   * @param {InfrastructureDomain} domain - The infrastructure domain to associate with the type.
+   * @returns {ComponentTypeBuilder} The builder instance for method chaining.
+   */
+  withInfrastructureDomain: (domain: InfrastructureDomain$1) => ComponentTypeBuilder;
+  /**
+   * Sets the PascalCase name for the type being built.
+   *
+   * @param {PascalCaseString} name - The PascalCase formatted name for the type.
+   * @returns {ComponentTypeBuilder} The builder instance for method chaining.
+   */
+  withName: (name: PascalCaseString$1) => ComponentTypeBuilder;
+  /**
+   * Resets the builder's internal state to default values.
+   *
+   * This method clears all previously configured properties and returns
+   * the builder to its initial state, allowing it to be reused for
+   * constructing a new Type instance.
+   *
+   * @returns {ComponentTypeBuilder} The builder instance for method chaining.
+   */
+  reset: () => ComponentTypeBuilder;
+  /**
+   * Validates and constructs the final Type object.
+   *
+   * This method performs validation on the configured properties to ensure
+   * the Type is valid (domain must be initialized and name must be in PascalCase).
+   * If validation fails, a SyntaxError is thrown.
+   *
+   * @returns {ComponentType} An immutable Type instance with the configured properties.
+   * @throws {SyntaxError} If the type configuration is invalid.
+   */
+  build: () => ComponentType;
+};
+//#endregion
+//#region src/values/generic_parameters.d.ts
+/**
+ * Represents a type definition for Parameters, which provides methods to retrieve required
+ * and optional fields by their corresponding names.
+ *
+ * @typedef {Object} GenericParameters
+ *
+ * @property {Function} getRequiredFieldByName - Retrieves a required field by its name.
+ *   Expects a string as input representing the field name and returns a record where keys
+ *   are of type string and values are objects.
+ *
+ * @property {Function} getOptionalFieldByName - Retrieves an optional field by its name.
+ *   Expects a string as input representing the field name and returns a record where keys
+ *   are of type string and values are objects.
+ */
+type GenericParameters = {
+  getRequiredFieldByName: (name: string) => Record<string, object>;
+  getOptionalFieldByName: (name: string) => Record<string, object>;
+  getAllFieldNames: () => string[];
+  push: (key: string, value: Record<string, object>) => void;
+  remove: (key: string) => void;
+  toMap: () => Record<string, object>;
+};
+//#endregion
+//#region src/component/link.d.ts
+/**
+ * Represents a link object with an identifier, type, and associated parameters.
+ *
+ * @typedef {Object} ComponentLink
+ * @property {ComponentId} id - The unique identifier for the link.
+ * @property {ComponentType} type - The type of the link, indicating its category or purpose.
+ * @property {Link.Parameters} parameters - A dictionary of configuration parameters,
+ * where keys are setting names and values are their corresponding configuration objects.
+ */
+type ComponentLink = {
+  id: ComponentId;
+  type: ComponentType;
+  parameters: Component.Link.Parameters;
+};
+/**
+ * A builder interface for constructing ComponentLink objects in a fluent and type-safe manner.
+ *
+ * The LinkBuilder provides methods to configure a ComponentLink's properties step-by-step,
+ * validate the configuration, and produce an immutable ComponentLink instance. It follows
+ * the builder pattern, allowing method chaining for a more readable API.
+ *
+ * @typedef {Object} LinkBuilder
+ */
+type LinkBuilder = {
+  /**
+   * Sets the identifier for the link being built.
+   *
+   * @param {ComponentId} id - The unique identifier to associate with the link.
+   * @returns {LinkBuilder} The builder instance for method chaining.
+   */
+  withId: (id: ComponentId) => LinkBuilder;
+  /**
+   * Sets the type for the link being built.
+   *
+   * @param {ComponentType} type - The type to associate with the link.
+   * @returns {LinkBuilder} The builder instance for method chaining.
+   */
+  withType: (type: ComponentType) => LinkBuilder;
+  /**
+   * Sets the parameters for the link being built.
+   *
+   * @param {Link.Parameters} parameters - The configuration parameters to associate with the link.
+   * @returns {LinkBuilder} The builder instance for method chaining.
+   */
+  withParameters: (parameters: Component.Link.Parameters) => LinkBuilder;
+  /**
+   * Resets the builder's internal state to default values.
+   *
+   * This method clears all previously configured properties and returns
+   * the builder to its initial state, allowing it to be reused for
+   * constructing a new ComponentLink instance.
+   *
+   * @returns {LinkBuilder} The builder instance for method chaining.
+   */
+  reset: () => LinkBuilder;
+  /**
+   * Validates and constructs the final ComponentLink object.
+   *
+   * This method performs validation on the configured properties to ensure
+   * the ComponentLink is valid (id must be initialized and type must be valid).
+   * If validation fails, a SyntaxError is thrown.
+   *
+   * @returns {ComponentLink} An immutable ComponentLink instance with the configured properties.
+   * @throws {SyntaxError} If the link configuration is invalid.
+   */
+  build: () => ComponentLink;
+};
+//#endregion
+//#region src/component/dependency.d.ts
+/**
+ * Represents a dependency with a specified type.
+ *
+ * This type can be used to define a specific dependency structure
+ * where the `type` property indicates the category or classification
+ * of the dependency.
+ *
+ * @typedef {Object} ComponentDependency
+ * @property {Type} type - Specifies the type of the dependency.
+ */
+type ComponentDependency = {
+  type: ComponentType;
+};
+//#endregion
+//#region src/component/entity.d.ts
+/**
+ * Represents an object structure where the `value` field contains
+ * a record of key-value pairs. The keys are strings, and the values
+ * are objects.
+ *
+ * This type is typically used to structure output data and ensure
+ * a consistent schema in which string keys map to object values.
+ *
+ * Example usage of this type might involve representing data returned
+ * from a service or API, where the output follows a defined format.
+ */
+type ComponentOutputFields = {
+  value: Record<string, object>;
+};
+/**
+ * A builder interface for constructing Component objects in a fluent and type-safe manner.
+ *
+ * The ComponentBuilder provides methods to configure a Component's properties step-by-step,
+ * validate the configuration, and produce an immutable Component instance. It follows
+ * the builder pattern, allowing method chaining for a more readable API.
+ *
+ * @typedef {Object} ComponentBuilder
+ */
+type ComponentBuilder = {
+  /**
+   * Sets the type for the component being built.
+   *
+   * @param {ComponentType} type - The type to associate with the component.
+   * @returns {ComponentBuilder} The builder instance for method chaining.
+   */
+  withType: (type: ComponentType) => ComponentBuilder;
+  /**
+   * Sets the identifier for the component being built.
+   *
+   * @param {ComponentId} id - The unique identifier to associate with the component.
+   * @returns {ComponentBuilder} The builder instance for method chaining.
+   */
+  withId: (id: ComponentId) => ComponentBuilder;
+  /**
+   * Sets the version for the component being built.
+   *
+   * @param {Version} version - The version to associate with the component.
+   * @returns {ComponentBuilder} The builder instance for method chaining.
+   */
+  withVersion: (version: Version$1) => ComponentBuilder;
+  /**
+   * Sets the display name for the component being built.
+   *
+   * @param {string} displayName - The display name to associate with the component.
+   * @returns {ComponentBuilder} The builder instance for method chaining.
+   */
+  withDisplayName: (displayName: string) => ComponentBuilder;
+  /**
+   * Sets the description for the component being built.
+   *
+   * @param {string} description - The description to associate with the component.
+   * @returns {ComponentBuilder} The builder instance for method chaining.
+   */
+  withDescription: (description: string) => ComponentBuilder;
+  /**
+   * Sets the parameters for the component being built.
+   *
+   * @param {Component.Parameters} parameters - The parameters to associate with the component.
+   * @returns {ComponentBuilder} The builder instance for method chaining.
+   */
+  withParameters: (parameters: Component.Parameters) => ComponentBuilder;
+  /**
+   * Sets the links for the component being built.
+   *
+   * @param {ComponentLink[]} links - The links to associate with the component.
+   * @returns {ComponentBuilder} The builder instance for method chaining.
+   */
+  withLinks: (links: ComponentLink[]) => ComponentBuilder;
+  /**
+   * Sets the dependencies for the component being built.
+   *
+   * @param {Dependency[]} dependencies - The dependencies to associate with the component.
+   * @returns {ComponentBuilder} The builder instance for method chaining.
+   */
+  withDependencies: (dependencies: ComponentDependency[]) => ComponentBuilder;
+  /**
+   * Resets the builder's internal state to default values.
+   *
+   * This method clears all previously configured properties and returns
+   * the builder to its initial state, allowing it to be reused for
+   * constructing a new Component instance.
+   *
+   * @returns {ComponentBuilder} The builder instance for method chaining.
+   */
+  reset: () => ComponentBuilder;
+  /**
+   * Validates and constructs the final Component object.
+   *
+   * This method performs validation on the configured properties to ensure
+   * the Component is valid (id, type, version, and display name must be valid).
+   * If validation fails, a SyntaxError is thrown.
+   *
+   * @returns {Component} An immutable Component instance with the configured properties.
+   * @throws {SyntaxError} If the component configuration is invalid.
+   */
+  build: () => Component;
+};
+//#endregion
+//#region src/component/index.d.ts
+declare namespace Component {
+  type Type = ComponentType;
+  namespace Type {
+    type Builder = ComponentTypeBuilder;
+    const getBuilder: () => ComponentTypeBuilder;
+  }
+  type Parameters = GenericParameters;
+  namespace Parameters {
+    const getInstance: () => GenericParameters;
+  }
+  type Link = ComponentLink;
+  namespace Link {
+    type Builder = LinkBuilder;
+    type Parameters = GenericParameters;
+    namespace Parameters {
+      const getInstance: () => GenericParameters;
+    }
+    const getBuilder: () => LinkBuilder;
+  }
+  type Id = ComponentId;
+  namespace Id {
+    type Builder = ComponentIdBuilder;
+    const getBuilder: () => ComponentIdBuilder;
+  }
+  type OutputFields = ComponentOutputFields;
+  type Builder = ComponentBuilder;
+  type Dependency = ComponentDependency;
+  const getBuilder: () => ComponentBuilder;
+}
+type Component = {
+  type: Component.Type;
+  id: Component.Id;
+  version: Version$1;
+  displayName: string;
+  description: string;
+  parameters: Component.Parameters;
+  outputFields: Component.OutputFields;
+  links: Component.Link[];
+  dependencies: Component.Dependency[];
+};
+//#endregion
+//#region src/values/service_delivery_model.d.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.
+ */
+declare enum ServiceDeliveryModel$1 {
+  IaaS = "IaaS",
+  CaaS = "CaaS",
+  PaaS = "PaaS",
+  FaaS = "FaaS",
+  SaaS = "SaaS"
+}
+//#endregion
+//#region src/fractal/component/type.d.ts
+/**
+ * Represents a blueprint component type that extends the base `Component.Type`
+ * with additional properties and modifications. This type omits the `equals`
+ * method from `Component.Type` and introduces its own implementation, along
+ * with a custom `serviceDeliveryModel` property.
+ *
+ * BlueprintComponentType provides a way to define a component's blueprint with
+ * a specific service delivery model while also enabling object equality
+ * comparisons customized to the requirements of blueprint components.
+ *
+ * Properties:
+ * - Inherits all properties from `Component.Type` except for the `equals` method.
+ * - Adds a `serviceDeliveryModel` property to specify how the service is delivered.
+ * - Reimplements the `equals` method for comparing two blueprint component types.
+ */
+type BlueprintComponentType = Component.Type & {
+  serviceDeliveryModel: ServiceDeliveryModel$1;
+  toString: () => string;
+};
+/**
+ * A builder interface for constructing Type objects in a fluent and type-safe manner.
+ *
+ * The TypeBuilder provides methods to configure a Type's properties step-by-step,
+ * validate the configuration, and produce an immutable Type instance. It follows
+ * the builder pattern, allowing method chaining for a more readable API.
+ *
+ * @typedef {Object} BlueprintComponentTypeBuilder
+ */
+type BlueprintComponentTypeBuilder = {
+  /**
+   * Sets the infrastructure domain for the type being built.
+   *
+   * @param {InfrastructureDomain} domain - The infrastructure domain to associate with the type.
+   * @returns {BlueprintComponentTypeBuilder} The builder instance for method chaining.
+   */
+  withInfrastructureDomain: (domain: InfrastructureDomain$1) => BlueprintComponentTypeBuilder;
+  /**
+   * Configures the builder to use the specified service delivery model.
+   *
+   * @param {ServiceDeliveryModel} serviceDeliveryModel - The service delivery model to be applied during the building process.
+   * @returns {BlueprintComponentTypeBuilder} The builder instance for chaining additional configurations.
+   */
+  withServiceDeliveryModel: (serviceDeliveryModel: ServiceDeliveryModel$1) => BlueprintComponentTypeBuilder;
+  /**
+   * Sets the PascalCase name for the type being built.
+   *
+   * @param {PascalCaseString} name - The PascalCase formatted name for the type.
+   * @returns {BlueprintComponentTypeBuilder} The builder instance for method chaining.
+   */
+  withName: (name: PascalCaseString$1) => BlueprintComponentTypeBuilder;
+  /**
+   * Resets the builder's internal state to default values.
+   *
+   * This method clears all previously configured properties and returns
+   * the builder to its initial state, allowing it to be reused for
+   * constructing a new Type instance.
+   *
+   * @returns {BlueprintComponentTypeBuilder} The builder instance for method chaining.
+   */
+  reset: () => BlueprintComponentTypeBuilder;
+  /**
+   * Validates and constructs the final Type object.
+   *
+   * This method performs validation on the configured properties to ensure
+   * the Type is valid (domain must be initialized and name must be in PascalCase).
+   * If validation fails, a SyntaxError is thrown.
+   *
+   * @returns {BlueprintComponentType} An immutable Type instance with the configured properties.
+   * @throws {SyntaxError} If the type configuration is invalid.
+   */
+  build: () => BlueprintComponentType;
+};
+//#endregion
+//#region src/fractal/component/dependency.d.ts
+/**
+ * Represents a dependency for a blueprint component.
+ *
+ * This type defines the structure to describe a single dependency within a blueprint system for component-based architectures.
+ *
+ * Properties:
+ * - `id`: The unique identifier of the component that is required as a dependency.
+ */
+type BlueprintComponentDependency = {
+  id: Component.Id;
+};
+//#endregion
+//#region src/fractal/component/entity.d.ts
+/**
+ * A type representing a builder for constructing a blueprint component.
+ * The builder pattern allows for configuring and constructing complex
+ * instances of blueprint components with a fluent API. Each method in
+ * this builder performs a configuration step, returning the builder instance
+ * to enable method chaining. Once fully configured, the `build` method finalizes
+ * the construction process and returns an immutable component instance.
+ */
+type BlueprintComponentBuilder = {
+  /**
+   * Sets the type for the component being built.
+   *
+   * @param {BlueprintComponentType} type - The type to associate with the component.
+   * @returns {BlueprintComponentBuilder} The builder instance for method chaining.
+   */
+  withType: (type: BlueprintComponentType) => BlueprintComponentBuilder;
+  /**
+   * Sets the identifier for the component being built.
+   *
+   * @param {Component.Id} id - The unique identifier to associate with the component.
+   * @returns {BlueprintComponentBuilder} The builder instance for method chaining.
+   */
+  withId: (id: Component.Id) => BlueprintComponentBuilder;
+  /**
+   * Sets the version for the component being built.
+   *
+   * @param {Version} version - The version to associate with the component.
+   * @returns {BlueprintComponentBuilder} The builder instance for method chaining.
+   */
+  withVersion: (version: Version$1) => BlueprintComponentBuilder;
+  /**
+   * Sets the display name for the component being built.
+   *
+   * @param {string} displayName - The display name to associate with the component.
+   * @returns {BlueprintComponentBuilder} The builder instance for method chaining.
+   */
+  withDisplayName: (displayName: string) => BlueprintComponentBuilder;
+  /**
+   * Sets the description for the component being built.
+   *
+   * @param {string} description - The description to associate with the component.
+   * @returns {BlueprintComponentBuilder} The builder instance for method chaining.
+   */
+  withDescription: (description: string) => BlueprintComponentBuilder;
+  /**
+   * Sets the parameters for the component being built.
+   *
+   * @param {Component.Parameters} parameters - The parameters to associate with the component.
+   * @returns {BlueprintComponentBuilder} The builder instance for method chaining.
+   */
+  withParameters: (parameters: Component.Parameters) => BlueprintComponentBuilder;
+  /**
+   * Sets the links for the component being built.
+   *
+   * @param {Component.Link[]} links - The links to associate with the component.
+   * @returns {BlueprintComponentBuilder} The builder instance for method chaining.
+   */
+  withLinks: (links: Component.Link[]) => BlueprintComponentBuilder;
+  /**
+   * Adds a list of dependencies to the BlueprintComponentBuilder.
+   *
+   * This function allows specifying dependencies that the component requires
+   * to function correctly. Each dependency is passed as a
+   * BlueprintComponentDependency object, which provides the necessary
+   * details of the dependency.
+   *
+   * @param {BlueprintComponentDependency[]} dependencies - An array of objects
+   * representing the component's dependencies.
+   * @returns {BlueprintComponentBuilder} The updated instance of the
+   * BlueprintComponentBuilder with the specified dependencies included.
+   */
+  withDependencies: (dependencies: BlueprintComponentDependency[]) => BlueprintComponentBuilder;
+  /**
+   * Adds or updates the `isLocked` attribute for the blueprint component.
+   *
+   * @param {boolean} value - Determines whether the component should be marked as locked.
+   *                          Pass `true` to lock the component or `false` to unlock it.
+   * @returns {BlueprintComponentBuilder} The instance of the blueprint component builder for method chaining.
+   */
+  withIsLocked: (value: boolean) => BlueprintComponentBuilder;
+  /**
+   * Configures the builder to recreate the component upon encountering a failure.
+   *
+   * @param {boolean} value - A boolean flag indicating whether the component should be recreated on failure.
+   *                          If true, the builder will regenerate the component when a failure occurs.
+   * @returns {BlueprintComponentBuilder} The builder instance for method chaining.
+   */
+  withRecreateOnFailure: (value: boolean) => BlueprintComponentBuilder;
+  /**
+   * Resets the builder's internal state to default values.
+   *
+   * This method clears all previously configured properties and returns
+   * the builder to its initial state, allowing it to be reused for
+   * constructing a new Component instance.
+   *
+   * @returns {BlueprintComponentBuilder} The builder instance for method chaining.
+   */
+  reset: () => BlueprintComponentBuilder;
+  /**
+   * Validates and constructs the final Component object.
+   *
+   * This method performs validation on the configured properties to ensure
+   * the Component is valid (id, type, version, and display name must be valid).
+   * If validation fails, a SyntaxError is thrown.
+   *
+   * @returns {BlueprintComponent} An immutable Component instance with the configured properties.
+   * @throws {SyntaxError} If the component configuration is invalid.
+   */
+  build: () => BlueprintComponent;
+};
+//#endregion
+//#region src/fractal/component/index.d.ts
+declare namespace BlueprintComponent {
+  type Type = BlueprintComponentType;
+  namespace Type {
+    type Builder = BlueprintComponentTypeBuilder;
+    const getBuilder: () => BlueprintComponentTypeBuilder;
+  }
+  type Id = Component.Id;
+  namespace Id {
+    type Builder = Component.Id.Builder;
+    const getBuilder: () => ComponentIdBuilder;
+  }
+  type Builder = BlueprintComponentBuilder;
+  type Dependency = BlueprintComponentDependency;
+  const getBuilder: () => BlueprintComponentBuilder;
+}
+type BlueprintComponent = Omit<Component, 'type' | 'dependencies'> & {
+  type: BlueprintComponent.Type;
+  dependencies: BlueprintComponent.Dependency[];
+  isLocked: boolean;
+  recreateOnFailure: boolean;
+};
+//#endregion
+//#region src/values/service_account_id.d.ts
+/**
+ * Represents a unique identifier for a service account.
+ *
+ * This type is used to encapsulate the value of a service account's unique ID as a string.
+ */
+type ServiceAccountId$1 = {
+  serviceAccountIdValue: string;
+};
+/**
+ * A builder type to facilitate the construction of a `ServiceAccountId` object.
+ * Provides methods for setting values, resetting the builder's state, and creating the final `ServiceAccountId`.
+ */
+type ServiceAccountIdBuilder = {
+  /**
+   * Sets a value to the builder for constructing a ServiceAccountId.
+   *
+   * @param {string} value - The value to be assigned to the builder.
+   * @returns {ServiceAccountIdBuilder} The instance of the builder with the specified value set.
+   */
+  withValue: (value: string) => ServiceAccountIdBuilder;
+  /**
+   * Resets the current state of the ServiceAccountIdBuilder instance, clearing any previously set values
+   * and returning the builder to its initial state.
+   *
+   * @returns {ServiceAccountIdBuilder} The current instance of the ServiceAccountIdBuilder for method chaining.
+   */
+  reset: () => ServiceAccountIdBuilder;
+  /**
+   * A method that initiates the creation or retrieval of a `ServiceAccountId`.
+   *
+   * @function
+   * @returns {ServiceAccountId} - The generated or fetched service account identifier.
+   */
+  build: () => ServiceAccountId$1;
+};
+declare namespace ServiceAccountId$1 {
+  const getBuilder: () => ServiceAccountIdBuilder;
+}
+//#endregion
+//#region src/values/service_account_credentials.d.ts
+/**
+ * Represents the credentials used for a service account.
+ * This includes the service account's unique identifier and secret key.
+ * The credentials are typically used for authenticating and authorizing
+ * access to services or APIs on behalf of the service account.
+ */
+type ServiceAccountCredentials$1 = {
+  id: ServiceAccountId$1;
+  secret: string;
+};
+/**
+ * Represents a builder for creating service account credentials.
+ */
+type ServiceAccountCredentialsBuilder = {
+  /**
+   * Assigns a specific `ServiceAccountId` to the builder object.
+   *
+   * @param {ServiceAccountId} value - The unique identifier for the service account.
+   * @returns {ServiceAccountCredentialsBuilder} The updated builder instance for chaining.
+   */
+  withId: (value: ServiceAccountId$1) => ServiceAccountCredentialsBuilder;
+  /**
+   * Attaches a secret to the service account credentials builder.
+   *
+   * This method allows you to provide a secret value that will be associated with the
+   * service account credentials being constructed. The secret is typically used
+   * for authentication purposes or secure communication with external services.
+   *
+   * @param {string} value - The secret value to be attached.
+   * @returns {ServiceAccountCredentialsBuilder} The updated instance of the service account credentials builder.
+   */
+  withSecret: (value: string) => ServiceAccountCredentialsBuilder;
+  /**
+   * Resets the current state of the ServiceAccountCredentialsBuilder instance,
+   * clearing any previously set data and restoring it to its initial default state.
+   *
+   * @returns {ServiceAccountCredentialsBuilder} The current instance of the builder for method chaining.
+   */
+  reset: () => ServiceAccountCredentialsBuilder;
+  /**
+   * A function that constructs and returns an instance of ServiceAccountCredentials.
+   * Typically used to build credentials required for authenticating or authorizing
+   * service account interactions.
+   *
+   * @function
+   * @returns {ServiceAccountCredentials} The generated service account credentials.
+   */
+  build: () => ServiceAccountCredentials$1;
+};
+declare namespace ServiceAccountCredentials$1 {
+  const getBuilder: () => ServiceAccountCredentialsBuilder;
+}
+//#endregion
+//#region src/fractal/entity.d.ts
+/**
+ * Represents a builder for creating and configuring Fractal objects.
+ */
+type FractalBuilder = {
+  /**
+   * Sets the identifier for the fractal using the provided value.
+   *
+   * @param {FractalId} value - The unique identifier to assign to the fractal.
+   * @returns {FractalBuilder} The instance of the FractalBuilder for method chaining.
+   */
+  withId: (value: FractalId) => FractalBuilder;
+  /**
+   * Sets the privacy flag for the FractalBuilder.
+   *
+   * @param {boolean} value - Indicates whether the entity should be marked as private.
+   * @returns {FractalBuilder} The updated instance of the FractalBuilder.
+   */
+  withIsPrivate: (value: boolean) => FractalBuilder;
+  /**
+   * Assigns a description to the fractal being built.
+   *
+   * @param {string} value - The description to associate with the fractal.
+   * @returns {FractalBuilder} The instance of the FractalBuilder to allow method chaining.
+   */
+  withDescription: (value: string) => FractalBuilder;
+  /**
+   * A method used to associate a set of components with a FractalBuilder instance.
+   *
+   * @param {BlueprintComponent[]} value - An array of BlueprintComponent objects to be linked to the FractalBuilder.
+   * @returns {FractalBuilder} The FractalBuilder instance with the specified components applied.
+   */
+  withComponents: (value: BlueprintComponent[]) => FractalBuilder;
+  /**
+   * Assigns a specified BlueprintComponent to the current FractalBuilder instance.
+   *
+   * @param {BlueprintComponent} value - The component to be added to the FractalBuilder.
+   * @returns {FractalBuilder} The updated instance of FractalBuilder for chaining further configurations.
+   */
+  withComponent: (value: BlueprintComponent) => FractalBuilder;
+  /**
+   * Resets the current state of the FractalBuilder to its initial configuration.
+   *
+   * @function
+   * @returns {FractalBuilder} Returns the updated FractalBuilder instance after resetting.
+   */
+  reset: () => FractalBuilder;
+  /**
+   * A function that generates and returns a new instance of a Fractal object.
+   *
+   * This function is typically used to construct complex structures or data
+   * representations that follow a fractal pattern. The returned Fractal object
+   * encapsulates the properties and behaviors associated with the fractal design.
+   *
+   * @function
+   * @returns {Fractal} A newly created instance of a Fractal object.
+   */
+  build: () => Fractal$1;
+};
+//#endregion
+//#region src/fractal/index.d.ts
+declare namespace Fractal$1 {
+  type Id = FractalId;
+  namespace Id {
+    type Builder = FractalIdBuilder;
+    const getBuilder: () => FractalIdBuilder;
+  }
+  type Component = BlueprintComponent;
+  namespace Component {
+    type Builder = BlueprintComponentBuilder;
+    const getBuilder: () => BlueprintComponentBuilder;
+    namespace Type {
+      type Builder = BlueprintComponentTypeBuilder;
+      const getBuilder: () => BlueprintComponentTypeBuilder;
+    }
+    type Id = BlueprintComponent.Id;
+    namespace Id {
+      type Builder = BlueprintComponent.Id.Builder;
+      const getBuilder: () => ComponentIdBuilder;
+    }
+  }
+  type Builder = FractalBuilder;
+  const getBuilder: () => FractalBuilder;
+}
+type Fractal$1 = {
+  id: Fractal$1.Id;
+  isPrivate: boolean;
+  description: string;
+  components: Fractal$1.Component[];
+  deploy: (credentials: ServiceAccountCredentials$1) => Promise<void>;
+  destroy: (credentials: ServiceAccountCredentials$1) => Promise<void>;
+};
+//#endregion
+//#region src/environment/id.d.ts
+/**
+ * Represents a unique identifier for an environment that includes type, ownership, and name information.
+ *
+ * This type encapsulates the details necessary to uniquely identify an environment,
+ * including its owning entity, a descriptive name, and utility methods to compare
+ * or represent the identifier as a string.
+ *
+ * Properties:
+ * - `ownerType`: Specifies the type of the owner associated with the environment.
+ * - `ownerId`: Uniquely identifies the owner of the environment.
+ * - `name`: The name of the environment formatted as a kebab-case string.
+ *
+ * Methods:
+ * - `equals`: Compares the current environment identifier with another `EnvironmentId` to check if they are identical.
+ * - `toString`: Converts the environment identifier into a string representation.
+ */
+type EnvironmentId = {
+  _type: 'environment';
+  ownerType: OwnerType$1;
+  ownerId: OwnerId$1;
+  name: KebabCaseString$1;
+  equals: (other: EnvironmentId) => boolean;
+  toString: () => string;
+};
+/**
+ * A builder utility to construct an EnvironmentId with various parameters.
+ * Provides a chainable API for setting properties and building the final object.
+ */
+type EnvironmentIdBuilder = {
+  /**
+   * Sets the owner type of the Id.
+   * @param ownerType - The type of the owner (e.g., Personal, Organization)
+   * @returns The builder instance for method chaining
+   */
+  withOwnerType: (ownerType: OwnerType$1) => EnvironmentIdBuilder;
+  /**
+   * Sets the owner ID of the Id.
+   * @param ownerId - The unique identifier of the owner
+   * @returns The builder instance for method chaining
+   */
+  withOwnerId: (ownerId: OwnerId$1) => EnvironmentIdBuilder;
+  /**
+   * Sets the name of the Id.
+   * @param name - The name in kebab-case format
+   * @returns The builder instance for method chaining
+   */
+  withName: (name: KebabCaseString$1) => EnvironmentIdBuilder;
+  /**
+   * Resets the builder to its default state, restoring all default values.
+   * @returns The builder instance for method chaining
+   */
+  reset: () => EnvironmentIdBuilder;
+  /**
+   * Constructs and returns the final Id object.
+   * @returns The constructed Id object
+   * @throws {SyntaxError} If the resulting Id is invalid
+   */
+  build: () => EnvironmentId;
+};
+//#endregion
+//#region src/environment/entity.d.ts
+type EnvironmentBuilder = {
+  withId: (id: Environment$1.Id) => EnvironmentBuilder;
+  withParameters: (parameters: Environment$1.Parameters) => EnvironmentBuilder;
+  reset: () => EnvironmentBuilder;
+  build: () => Environment$1;
+};
+//#endregion
+//#region src/environment/index.d.ts
+declare namespace Environment$1 {
+  type Id = EnvironmentId;
+  namespace Id {
+    type Builder = EnvironmentIdBuilder;
+    const getBuilder: () => EnvironmentIdBuilder;
+  }
+  type Parameters = GenericParameters;
+  type Builder = EnvironmentBuilder;
+  const getBuilder: () => EnvironmentBuilder;
+}
+type Environment$1 = {
+  id: Environment$1.Id;
+  parameters: Environment$1.Parameters;
+};
+//#endregion
+//#region src/live_system/id.d.ts
+/**
+ * Represents the unique identifier for a live system instance in a specific bounded context.
+ *
+ * @typedef {Object} LiveSystemId
+ * @property {BoundedContext.Id} boundedContextId - The identifier of the bounded context associated with the live system.
+ * @property {KebabCaseString} name - The name of the live system in kebab-case format.
+ * @property {function(): string} toString - A method that converts the live system identifier to its string representation.
+ */
+type LiveSystemId = {
+  boundedContextId: BoundedContext$1.Id;
+  name: KebabCaseString$1;
+  toString: () => string;
+};
+/**
+ * A builder for creating instances of LiveSystemId. Allows setting various properties
+ * before producing the final immutable LiveSystemId object.
+ */
+type LiveSystemIdBuilder = {
+  /**
+   * Sets the bounded context identifier for the live system ID builder.
+   *
+   * This method assigns a specific bounded context ID to the builder, enabling it
+   * to associate the resulting system identifiers with the provided context. The
+   * bounded context ID uniquely identifies the context within which the system
+   * operates, ensuring logical separation and consistency across different systems.
+   *
+   * @param {BoundedContext.Id} value - The unique identifier of the bounded context.
+   * @returns {LiveSystemIdBuilder} The builder instance with the bounded context ID applied.
+   */
+  withBoundedContextId: (value: BoundedContext$1.Id) => LiveSystemIdBuilder;
+  /**
+   * A method that assigns a name to the builder object.
+   *
+   * @param {KebabCaseString} name - The name to be set, formatted as a kebab-case string.
+   * @returns {LiveSystemIdBuilder} Returns an updated instance of the LiveSystemIdBuilder.
+   */
+  withName: (name: KebabCaseString$1) => LiveSystemIdBuilder;
+  /**
+   * Resets the current state of the LiveSystemIdBuilder instance to its initial configuration.
+   *
+   * @returns {LiveSystemIdBuilder} A new instance of LiveSystemIdBuilder with default settings.
+   */
+  reset: () => LiveSystemIdBuilder;
+  /**
+   * Represents a function that generates or retrieves a `LiveSystemId`.
+   * The function is intended to construct or return an identifier for
+   * a live system component, which may represent an active or dynamic
+   * system entity.
+   *
+   * @function
+   * @returns {LiveSystemId} A unique identifier for a live system.
+   */
+  build: () => LiveSystemId;
+};
+//#endregion
+//#region src/live_system/component/entity.d.ts
+/**
+ * A builder interface for constructing instances of LiveSystemComponent with a fluent API.
+ */
+type LiveSystemComponentBuilder = {
+  /**
+   * Configures the builder to associate a specific type with the system component.
+   *
+   * @param {BlueprintComponentType} type - The type of the system component to be set.
+   * @returns {LiveSystemComponentBuilder} The builder instance, enabling method chaining.
+   */
+  withType: (type: BlueprintComponentType) => LiveSystemComponentBuilder;
+  /**
+   * Associates a specific identifier with a component in the builder pattern.
+   *
+   * @param {Component.Id} id - The unique identifier to be assigned to the component.
+   * @returns {LiveSystemComponentBuilder} The builder instance for further configuration.
+   */
+  withId: (id: Component.Id) => LiveSystemComponentBuilder;
+  /**
+   * Sets the version for the LiveSystemComponentBuilder.
+   *
+   * @param {Version} version - The version to be set for the builder.
+   * @returns {LiveSystemComponentBuilder} The updated instance of the builder with the specified version.
+   */
+  withVersion: (version: Version$1) => LiveSystemComponentBuilder;
+  /**
+   * Sets a display name for the component being built.
+   *
+   * This method allows specifying a human-readable name for the component,
+   * which can be useful for debugging or identification purposes.
+   *
+   * @param {string} displayName - The display name to be assigned to the component.
+   * @returns {LiveSystemComponentBuilder} The builder instance, allowing for method chaining.
+   */
+  withDisplayName: (displayName: string) => LiveSystemComponentBuilder;
+  /**
+   * Attaches a description to the component builder.
+   *
+   * @param {string} description - The description to associate with the component.
+   * @returns {LiveSystemComponentBuilder} The current instance of the builder.
+   */
+  withDescription: (description: string) => LiveSystemComponentBuilder;
+  /**
+   * Configures the LiveSystemComponentBuilder with the specified parameters.
+   *
+   * @param {Component.Parameters} parameters - The parameters to be applied to the component builder.
+   * @returns {LiveSystemComponentBuilder} The instance of the builder with the updated configuration.
+   */
+  withParameters: (parameters: Component.Parameters) => LiveSystemComponentBuilder;
+  /**
+   * Configures the component builder with a collection of links.
+   * This method allows adding a list of links to the component being built,
+   * enabling navigation or connectivity between different components or resources within the system.
+   *
+   * @param {Component.Link[]} links - An array of links to include in the component.
+   * @returns {LiveSystemComponentBuilder} The current instance of the component builder, updated with the provided links.
+   */
+  withLinks: (links: Component.Link[]) => LiveSystemComponentBuilder;
+  /**
+   * A function that initializes a LiveSystemComponentBuilder with the specified dependencies.
+   *
+   * @param {BlueprintComponentDependency[]} dependencies - An array of blueprint component dependencies required for construction.
+   * @returns {LiveSystemComponentBuilder} A builder instance configured with the provided dependencies.
+   */
+  withDependencies: (dependencies: BlueprintComponentDependency[]) => LiveSystemComponentBuilder;
+  /**
+   * Sets the locked state of the component.
+   *
+   * @param {boolean} value - Indicates whether the component should be locked.
+   * @returns {LiveSystemComponentBuilder} The builder instance for chaining additional configuration methods.
+   */
+  withIsLocked: (value: boolean) => LiveSystemComponentBuilder;
+  /**
+   * Configures the system component builder to recreate the component upon failure, based on the specified flag.
+   *
+   * @param {boolean} value - A boolean indicating whether the component should be recreated on failure.
+   *                          Passing `true` enables recreation on failure, while `false` disables it.
+   * @returns {LiveSystemComponentBuilder} The current instance of the LiveSystemComponentBuilder
+   *                                        for method chaining.
+   */
+  withRecreateOnFailure: (value: boolean) => LiveSystemComponentBuilder;
+  /**
+   * Configures the LiveSystemComponentBuilder to use the specified provider.
+   *
+   * @param {LiveSystemComponent.Provider} value - The provider to associate with the LiveSystemComponentBuilder.
+   * @returns {LiveSystemComponentBuilder} The updated instance of LiveSystemComponentBuilder with the specified provider.
+   */
+  withProvider: (value: LiveSystemComponent.Provider) => LiveSystemComponentBuilder;
+  /**
+   * Resets the current configuration of the LiveSystemComponentBuilder instance
+   * to its initial state.
+   *
+   * @returns {LiveSystemComponentBuilder} A reference to the same builder instance,
+   * allowing for method chaining.
+   */
+  reset: () => LiveSystemComponentBuilder;
+  /**
+   * Function that generates and returns a LiveSystemComponent instance.
+   * The implementation defines the specific behavior and structure
+   * of the returned LiveSystemComponent.
+   *
+   * @returns {LiveSystemComponent} A new instance of a LiveSystemComponent.
+   */
+  build: () => LiveSystemComponent;
+};
+//#endregion
+//#region src/live_system/component/index.d.ts
+declare namespace LiveSystemComponent {
+  type Status = 'Unknown' | 'Instantiating' | 'Active' | 'Failed' | 'Mutating' | 'Deleting' | 'Cancelled';
+  type Provider = 'Unknown' | 'AWS' | 'GCP' | 'Azure' | 'OCI' | 'Hetzner' | 'CaaS' | 'SaaS';
+  type Builder = LiveSystemComponentBuilder;
+  const getBuilder: () => LiveSystemComponentBuilder;
+}
+type LiveSystemComponent = BlueprintComponent & {
+  status: LiveSystemComponent.Status;
+  lastUpdated: Date;
+  lastOperationRetried: number;
+  provider: LiveSystemComponent.Provider;
+  lastOperationStatusMessage: string;
+  errorCode: string;
+};
+//#endregion
+//#region src/live_system/entity.d.ts
+/**
+ * A builder interface for constructing a LiveSystem instance with various configurations.
+ */
+type LiveSystemBuilder = {
+  /**
+   * Sets the identifier for the LiveSystemBuilder instance.
+   *
+   * @param {LiveSystemId} value - The unique identifier to associate with the LiveSystemBuilder.
+   * @returns {LiveSystemBuilder} The current instance of the LiveSystemBuilder for chaining further configurations.
+   */
+  withId: (value: LiveSystemId) => LiveSystemBuilder;
+  /**
+   * A method that assigns a Fractal ID to the live system builder.
+   *
+   * @param {Fractal.Id} value - The unique identifier associated with the fractal.
+   * @returns {LiveSystemBuilder} The current instance of the live system builder, allowing method chaining.
+   */
+  withFractalId: (value: Fractal$1.Id) => LiveSystemBuilder;
+  /**
+   * Sets the description for the system being built.
+   *
+   * @param {string} value - The description to be assigned.
+   * @returns {LiveSystemBuilder} The builder instance to allow method chaining.
+   */
+  withDescription: (value: string) => LiveSystemBuilder;
+  /**
+   * Configures the current builder with the specified set of system components.
+   *
+   * @param {LiveSystemComponent[]} value - An array of components to be added to the system.
+   * @returns {LiveSystemBuilder} The updated instance of the builder for method chaining.
+   */
+  withComponents: (value: LiveSystemComponent[]) => LiveSystemBuilder;
+  /**
+   * Attaches a specified component to the current LiveSystemBuilder instance.
+   *
+   * @param {LiveSystemComponent} value - The component to be added to the system.
+   * @returns {LiveSystemBuilder} The updated LiveSystemBuilder instance, allowing for further configuration or chaining of components.
+   */
+  withComponent: (value: LiveSystemComponent) => LiveSystemBuilder;
+  /**
+   * A method that sets a generic provider for the live system builder.
+   *
+   * @param {LiveSystemComponent.Provider} value - The provider instance to be applied within the live system.
+   * @returns {LiveSystemBuilder} The current instance of the live system builder, allowing for method chaining.
+   */
+  withGenericProvider: (value: LiveSystemComponent.Provider) => LiveSystemBuilder;
+  /**
+   * Sets the parameters for the live system being built.
+   *
+   * @param {LiveSystem.Parameters} parameters - The parameters to associate with the live system.
+   * @returns {ComponentBuilder} The builder instance for method chaining.
+   */
+  withParameters: (parameters: Component.Parameters) => LiveSystemBuilder;
+  /**
+   * Configures the LiveSystemBuilder instance with the specified environment.
+   *
+   * @param {Environment} environment - The environment configuration to be applied.
+   * @returns {LiveSystemBuilder} The updated LiveSystemBuilder instance configured with the provided environment.
+   */
+  withEnvironment: (environment: Environment) => LiveSystemBuilder;
+  /**
+   * Resets the current state of the LiveSystemBuilder to its initial configuration.
+   * This operation typically clears any modifications or settings that have been applied
+   * and returns a fresh instance ready for reconfiguration.
+   *
+   * @function
+   * @returns {LiveSystemBuilder} A new instance of the LiveSystemBuilder with default settings.
+   */
+  reset: () => LiveSystemBuilder;
+  /**
+   * A method or function that, when invoked, initiates the creation or assembly process
+   * to produce an instance of the `LiveSystem`. The returned `LiveSystem` is a fully
+   * operational system ready to perform its designated tasks or services.
+   *
+   * @returns {LiveSystem} An instance of the `LiveSystem` representing the constructed system.
+   */
+  build: () => LiveSystem$1;
+};
+//#endregion
+//#region src/live_system/index.d.ts
+declare namespace LiveSystem$1 {
+  type Status = 'Unknown' | 'Mutating' | 'Active' | 'FailedMutation' | 'Processing' | 'Error' | 'Ready' | 'Deleting' | 'Stale';
+  type Id = LiveSystemId;
+  namespace Id {
+    type Builder = LiveSystemIdBuilder;
+    const getBuilder: () => LiveSystemIdBuilder;
+  }
+  type Component = LiveSystemComponent;
+  namespace Component {
+    type Builder = LiveSystemComponentBuilder;
+    const getBuilder: () => LiveSystemComponentBuilder;
+  }
+  type Parameters = GenericParameters;
+  type Builder = LiveSystemBuilder;
+  const getBuilder: () => LiveSystemBuilder;
+}
+type LiveSystem$1 = {
+  id: LiveSystemId;
+  requesterId: string;
+  fractalId: Fractal$1.Id;
+  description: string;
+  status: LiveSystem$1.Status;
+  statusMessage: string;
+  components: LiveSystemComponent[];
+  genericProvider: LiveSystemComponent.Provider;
+  parameters: LiveSystem$1.Parameters;
+  environment: Environment$1;
+  createdAt: Date;
+  updatedAt: Date;
+  deploy: (credentials: ServiceAccountCredentials$1) => Promise<void>;
+  destroy: (credentials: ServiceAccountCredentials$1) => Promise<void>;
+};
+//#endregion
+//#region src/index.d.ts
+declare const BoundedContext: typeof BoundedContext$1;
+type BoundedContext = BoundedContext$1;
+declare const Fractal: typeof Fractal$1;
+type Fractal = Fractal$1;
+declare const InfrastructureDomain: typeof InfrastructureDomain$1;
+type InfrastructureDomain = InfrastructureDomain$1;
+declare const KebabCaseString: typeof KebabCaseString$1;
+type KebabCaseString = KebabCaseString$1;
+declare const OwnerId: typeof OwnerId$1;
+type OwnerId = OwnerId$1;
+declare const OwnerType: typeof OwnerType$1;
+type OwnerType = OwnerType$1;
+declare const PascalCaseString: typeof PascalCaseString$1;
+type PascalCaseString = PascalCaseString$1;
+declare const ServiceAccountCredentials: typeof ServiceAccountCredentials$1;
+type ServiceAccountCredentials = ServiceAccountCredentials$1;
+declare const ServiceAccountId: typeof ServiceAccountId$1;
+type ServiceAccountId = ServiceAccountId$1;
+declare const ServiceDeliveryModel: typeof ServiceDeliveryModel$1;
+type ServiceDeliveryModel = ServiceDeliveryModel$1;
+declare const Version: typeof Version$1;
+type Version = Version$1;
+declare const Environment: typeof Environment$1;
+type Environment = Environment$1;
+declare const LiveSystem: typeof LiveSystem$1;
+type LiveSystem = LiveSystem$1;
+//#endregion
+export { BoundedContext, Environment, Fractal, InfrastructureDomain, KebabCaseString, LiveSystem, OwnerId, OwnerType, PascalCaseString, ServiceAccountCredentials, ServiceAccountId, ServiceDeliveryModel, Version };