@fractal_cloud/sdk 0.1.0 → 0.1.2

package/dist/index.d.mts

@@ -0,0 +1,1176 @@
+//#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 = {
+  kebabValue: 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;
+};
+/**
+ * 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 = {
+  ownerIdValue: 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 = {
+  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;
+  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 = {
+  pascalValue: 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 {GenericParameters} 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: GenericParameters;
+};
+/**
+ * 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 {GenericParameters} parameters - The configuration parameters to associate with the link.
+   * @returns {LinkBuilder} The builder instance for method chaining.
+   */
+  withParameters: (parameters: GenericParameters) => 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 {GenericParameters} parameters - The parameters to associate with the component.
+   * @returns {ComponentBuilder} The builder instance for method chaining.
+   */
+  withParameters: (parameters: GenericParameters) => 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 = Omit<Component.Type, 'equals'> & {
+  serviceDeliveryModel: ServiceDeliveryModel$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} 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
+/**
+ */
+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 {GenericParameters} parameters - The parameters to associate with the component.
+   * @returns {BlueprintComponentBuilder} The builder instance for method chaining.
+   */
+  withParameters: (parameters: GenericParameters) => 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
+type FractalBuilder = {
+  withId: (value: FractalId) => FractalBuilder;
+  withIsPrivate: (value: boolean) => FractalBuilder;
+  withDescription: (value: string) => FractalBuilder;
+  withComponents: (value: BlueprintComponent[]) => FractalBuilder;
+  withComponent: (value: BlueprintComponent) => FractalBuilder;
+  reset: () => FractalBuilder;
+  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/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;
+//#endregion
+export { BoundedContext, Fractal, InfrastructureDomain, KebabCaseString, OwnerId, OwnerType, PascalCaseString, ServiceAccountCredentials, ServiceAccountId, ServiceDeliveryModel, Version };