@fractal_cloud/sdk 0.1.2 → 1.1.0

package/dist/index.d.mts

@@ -10,7 +10,10 @@
  * where consistent, hyphen-delimited identifiers are required.
  */
 type KebabCaseString$1 = {
-  kebabValue: string;
+  _type: 'kebab';
+  value: string;
+  equals: (other: KebabCaseString$1) => boolean;
+  toString: () => string;
 };
 /**
  * Builder interface for constructing KebabCaseString objects.
@@ -52,6 +55,7 @@ declare namespace KebabCaseString$1 {
 type ComponentId = {
   value: KebabCaseString$1;
   equals: (other: ComponentId) => boolean;
+  toString: () => string;
 };
 /**
  * Builder interface for constructing ComponentId instances.
@@ -113,7 +117,9 @@ declare enum OwnerType$1 {
  * This convention capitalizes the first letter of each concatenated word without any spaces, dashes, or underscores.
  */
 type OwnerId$1 = {
-  ownerIdValue: string;
+  _type: 'ownerId';
+  value: string;
+  toString: () => string;
 };
 /**
  * Builder interface for constructing OwnerId objects.
@@ -158,6 +164,7 @@ declare namespace OwnerId$1 {
  * @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;
@@ -349,6 +356,7 @@ type FractalId = {
   boundedContextId: BoundedContext$1.Id;
   name: KebabCaseString$1;
   version: Version$1;
+  equals: (other: FractalId) => boolean;
   toString: () => string;
 };
 /**
@@ -405,7 +413,10 @@ type FractalIdBuilder = {
  * Commonly used in naming conventions for programming constructs such as types, classes, or enums.
  */
 type PascalCaseString$1 = {
-  pascalValue: string;
+  _type: 'pascal';
+  value: string;
+  equals: (other: PascalCaseString$1) => boolean;
+  toString: () => string;
 };
 /**
  * Builder interface for constructing PascalCaseString objects.
@@ -553,13 +564,13 @@ type GenericParameters = {
  * @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,
+ * @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: GenericParameters;
+  parameters: Component.Link.Parameters;
 };
 /**
  * A builder interface for constructing ComponentLink objects in a fluent and type-safe manner.
@@ -588,10 +599,10 @@ type LinkBuilder = {
   /**
    * Sets the parameters for the link being built.
    *
-   * @param {GenericParameters} parameters - The configuration parameters to associate with the link.
+   * @param {Link.Parameters} parameters - The configuration parameters to associate with the link.
    * @returns {LinkBuilder} The builder instance for method chaining.
    */
-  withParameters: (parameters: GenericParameters) => LinkBuilder;
+  withParameters: (parameters: Component.Link.Parameters) => LinkBuilder;
   /**
    * Resets the builder's internal state to default values.
    *
@@ -693,10 +704,10 @@ type ComponentBuilder = {
   /**
    * Sets the parameters for the component being built.
    *
-   * @param {GenericParameters} parameters - The parameters to associate with the component.
+   * @param {Component.Parameters} parameters - The parameters to associate with the component.
    * @returns {ComponentBuilder} The builder instance for method chaining.
    */
-  withParameters: (parameters: GenericParameters) => ComponentBuilder;
+  withParameters: (parameters: Component.Parameters) => ComponentBuilder;
   /**
    * Sets the links for the component being built.
    *
@@ -812,8 +823,9 @@ declare enum ServiceDeliveryModel$1 {
  * - 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'> & {
+type BlueprintComponentType = Component.Type & {
   serviceDeliveryModel: ServiceDeliveryModel$1;
+  toString: () => string;
 };
 /**
  * A builder interface for constructing Type objects in a fluent and type-safe manner.
@@ -884,6 +896,12 @@ type BlueprintComponentDependency = {
 //#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 = {
   /**
@@ -924,10 +942,10 @@ type BlueprintComponentBuilder = {
   /**
    * Sets the parameters for the component being built.
    *
-   * @param {GenericParameters} parameters - The parameters to associate with the component.
+   * @param {Component.Parameters} parameters - The parameters to associate with the component.
    * @returns {BlueprintComponentBuilder} The builder instance for method chaining.
    */
-  withParameters: (parameters: GenericParameters) => BlueprintComponentBuilder;
+  withParameters: (parameters: Component.Parameters) => BlueprintComponentBuilder;
   /**
    * Sets the links for the component being built.
    *
@@ -1106,13 +1124,62 @@ declare namespace ServiceAccountCredentials$1 {
 }
 //#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
@@ -1149,6 +1216,1587 @@ type Fractal$1 = {
   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/fractal/component/network_and_compute/iaas/vm.d.ts
+type VmPortLink = {
+  target: VirtualMachineNode;
+  fromPort: number;
+  toPort?: number;
+  protocol?: string;
+};
+type VirtualMachineNode = {
+  readonly component: BlueprintComponent;
+  readonly components: ReadonlyArray<BlueprintComponent>;
+  withLinks: (links: VmPortLink[]) => VirtualMachineNode;
+};
+type VirtualMachineBuilder = {
+  withId: (id: string) => VirtualMachineBuilder;
+  withVersion: (major: number, minor: number, patch: number) => VirtualMachineBuilder;
+  withDisplayName: (displayName: string) => VirtualMachineBuilder;
+  withDescription: (description: string) => VirtualMachineBuilder;
+  withLinks: (links: ComponentLink[]) => VirtualMachineBuilder;
+  build: () => BlueprintComponent;
+};
+type VirtualMachineConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+};
+declare namespace VirtualMachine {
+  const getBuilder: () => VirtualMachineBuilder;
+  const create: (config: VirtualMachineConfig) => VirtualMachineNode;
+}
+//#endregion
+//#region src/fractal/component/custom_workloads/caas/workload.d.ts
+/**
+ * Link from one Workload to another, declaring a traffic rule.
+ * The agent derives managed SG egress/ingress rules from these.
+ */
+type WorkloadPortLink = {
+  target: WorkloadNode;
+  fromPort: number;
+  toPort?: number;
+  protocol?: string;
+};
+type WorkloadNode = {
+  readonly component: BlueprintComponent;
+  readonly components: ReadonlyArray<BlueprintComponent>;
+  withLinks: (links: WorkloadPortLink[]) => WorkloadNode;
+  withSecurityGroups: (sgs: BlueprintComponent[]) => WorkloadNode;
+};
+type WorkloadBuilder = {
+  withId: (id: string) => WorkloadBuilder;
+  withVersion: (major: number, minor: number, patch: number) => WorkloadBuilder;
+  withDisplayName: (displayName: string) => WorkloadBuilder;
+  withDescription: (description: string) => WorkloadBuilder;
+  withContainerImage: (image: string) => WorkloadBuilder;
+  withContainerPort: (port: number) => WorkloadBuilder;
+  withContainerName: (name: string) => WorkloadBuilder;
+  withCpu: (cpu: string) => WorkloadBuilder;
+  withMemory: (memory: string) => WorkloadBuilder;
+  withDesiredCount: (count: number) => WorkloadBuilder;
+  build: () => BlueprintComponent;
+};
+type WorkloadConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  containerImage: string;
+  containerPort?: number;
+  containerName?: string;
+  cpu?: string;
+  memory?: string;
+  desiredCount?: number;
+};
+declare namespace Workload {
+  const getBuilder: () => WorkloadBuilder;
+  const create: (config: WorkloadConfig) => WorkloadNode;
+}
+//#endregion
+//#region src/fractal/component/network_and_compute/iaas/subnet.d.ts
+type SubnetNode = {
+  readonly subnet: BlueprintComponent;
+  readonly virtualMachines: ReadonlyArray<BlueprintComponent>;
+  readonly workloads: ReadonlyArray<BlueprintComponent>;
+  readonly components: ReadonlyArray<BlueprintComponent>;
+  withVirtualMachines: (vms: VirtualMachineNode[]) => SubnetNode;
+  withWorkloads: (workloads: ReadonlyArray<WorkloadNode>) => SubnetNode;
+};
+type SubnetResult = {
+  readonly subnet: BlueprintComponent;
+  readonly virtualMachines: ReadonlyArray<BlueprintComponent>;
+  readonly components: ReadonlyArray<BlueprintComponent>;
+};
+type SubnetBuilder = {
+  withId: (id: string) => SubnetBuilder;
+  withVersion: (major: number, minor: number, patch: number) => SubnetBuilder;
+  withDisplayName: (displayName: string) => SubnetBuilder;
+  withDescription: (description: string) => SubnetBuilder;
+  withCidrBlock: (cidrBlock: string) => SubnetBuilder;
+  withVirtualMachine: (builder: VirtualMachineBuilder) => SubnetBuilder;
+  withLinks: (links: ComponentLink[]) => SubnetBuilder;
+  build: () => SubnetResult;
+};
+type SubnetConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  cidrBlock?: string;
+};
+declare namespace Subnet {
+  const getBuilder: () => SubnetBuilder;
+  const create: (config: SubnetConfig) => SubnetNode;
+}
+//#endregion
+//#region src/fractal/component/network_and_compute/iaas/security_group.d.ts
+type IngressRule = {
+  protocol?: string;
+  fromPort: number;
+  toPort?: number;
+  sourceCidr?: string;
+  sourceGroupId?: string;
+};
+type SecurityGroupBuilder = {
+  withId: (id: string) => SecurityGroupBuilder;
+  withVersion: (major: number, minor: number, patch: number) => SecurityGroupBuilder;
+  withDisplayName: (displayName: string) => SecurityGroupBuilder;
+  withDescription: (description: string) => SecurityGroupBuilder;
+  withIngressRules: (rules: IngressRule[]) => SecurityGroupBuilder;
+  withLinks: (links: ComponentLink[]) => SecurityGroupBuilder;
+  build: () => BlueprintComponent;
+};
+type SecurityGroupConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description: string;
+  ingressRules?: IngressRule[];
+};
+declare namespace SecurityGroup {
+  const getBuilder: () => SecurityGroupBuilder;
+  const create: (config: SecurityGroupConfig) => BlueprintComponent;
+}
+//#endregion
+//#region src/fractal/component/network_and_compute/iaas/virtual_network.d.ts
+type VirtualNetworkNode = {
+  readonly vpc: BlueprintComponent;
+  readonly subnets: ReadonlyArray<BlueprintComponent>;
+  readonly securityGroups: ReadonlyArray<BlueprintComponent>;
+  readonly virtualMachines: ReadonlyArray<BlueprintComponent>;
+  readonly workloads: ReadonlyArray<BlueprintComponent>;
+  readonly components: ReadonlyArray<BlueprintComponent>;
+  withSubnets: (subnets: SubnetNode[]) => VirtualNetworkNode;
+  withSecurityGroups: (sgs: BlueprintComponent[]) => VirtualNetworkNode;
+};
+type VirtualNetworkResult = {
+  readonly vpc: BlueprintComponent;
+  readonly subnets: ReadonlyArray<BlueprintComponent>;
+  readonly securityGroups: ReadonlyArray<BlueprintComponent>;
+  readonly virtualMachines: ReadonlyArray<BlueprintComponent>;
+  readonly workloads: ReadonlyArray<BlueprintComponent>;
+  readonly components: ReadonlyArray<BlueprintComponent>;
+};
+type VirtualNetworkBuilder = {
+  withId: (id: string) => VirtualNetworkBuilder;
+  withVersion: (major: number, minor: number, patch: number) => VirtualNetworkBuilder;
+  withDisplayName: (displayName: string) => VirtualNetworkBuilder;
+  withDescription: (description: string) => VirtualNetworkBuilder;
+  withCidrBlock: (cidrBlock: string) => VirtualNetworkBuilder;
+  withSubnet: (builder: SubnetBuilder) => VirtualNetworkBuilder;
+  withSecurityGroup: (builder: SecurityGroupBuilder) => VirtualNetworkBuilder;
+  withLinks: (links: ComponentLink[]) => VirtualNetworkBuilder;
+  build: () => VirtualNetworkResult;
+};
+type VirtualNetworkConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  cidrBlock?: string;
+};
+declare namespace VirtualNetwork {
+  const getBuilder: () => VirtualNetworkBuilder;
+  const create: (config: VirtualNetworkConfig) => VirtualNetworkNode;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/vpc.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description, cidrBlock,
+ * dependencies, links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedAwsVpcBuilder = {
+  withInstanceTenancy: (instanceTenancy: 'default' | 'dedicated') => SatisfiedAwsVpcBuilder;
+  withEnableDnsSupport: (enable: boolean) => SatisfiedAwsVpcBuilder;
+  withEnableDnsHostnames: (enable: boolean) => SatisfiedAwsVpcBuilder;
+  build: () => LiveSystemComponent;
+};
+type AwsVpcBuilder = {
+  withId: (id: string) => AwsVpcBuilder;
+  withVersion: (major: number, minor: number, patch: number) => AwsVpcBuilder;
+  withDisplayName: (displayName: string) => AwsVpcBuilder;
+  withDescription: (description: string) => AwsVpcBuilder;
+  withCidrBlock: (cidrBlock: string) => AwsVpcBuilder;
+  withInstanceTenancy: (instanceTenancy: 'default' | 'dedicated') => AwsVpcBuilder;
+  withEnableDnsSupport: (enable: boolean) => AwsVpcBuilder;
+  withEnableDnsHostnames: (enable: boolean) => AwsVpcBuilder;
+  build: () => LiveSystemComponent;
+};
+type AwsVpcConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  cidrBlock: string;
+  instanceTenancy?: 'default' | 'dedicated';
+  enableDnsSupport?: boolean;
+  enableDnsHostnames?: boolean;
+};
+declare namespace AwsVpc {
+  const getBuilder: () => AwsVpcBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedAwsVpcBuilder;
+  const create: (config: AwsVpcConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/subnet.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description, cidrBlock,
+ * dependencies, links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedAwsSubnetBuilder = {
+  withAvailabilityZone: (availabilityZone: string) => SatisfiedAwsSubnetBuilder;
+  build: () => LiveSystemComponent;
+};
+type AwsSubnetBuilder = {
+  withId: (id: string) => AwsSubnetBuilder;
+  withVersion: (major: number, minor: number, patch: number) => AwsSubnetBuilder;
+  withDisplayName: (displayName: string) => AwsSubnetBuilder;
+  withDescription: (description: string) => AwsSubnetBuilder;
+  withCidrBlock: (cidrBlock: string) => AwsSubnetBuilder;
+  withAvailabilityZone: (availabilityZone: string) => AwsSubnetBuilder;
+  build: () => LiveSystemComponent;
+};
+type AwsSubnetConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  cidrBlock: string;
+  availabilityZone: string;
+};
+declare namespace AwsSubnet {
+  const getBuilder: () => AwsSubnetBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedAwsSubnetBuilder;
+  const create: (config: AwsSubnetConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/security_group.d.ts
+/**
+ * Returned by satisfy() — structural properties (id, version, displayName,
+ * description, dependencies, links, ingressRules) are locked to the blueprint
+ * and cannot be overridden.
+ */
+type SatisfiedAwsSecurityGroupBuilder = {
+  build: () => LiveSystemComponent;
+};
+type AwsSecurityGroupBuilder = {
+  withId: (id: string) => AwsSecurityGroupBuilder;
+  withVersion: (major: number, minor: number, patch: number) => AwsSecurityGroupBuilder;
+  withDisplayName: (displayName: string) => AwsSecurityGroupBuilder;
+  withDescription: (description: string) => AwsSecurityGroupBuilder;
+  withIngressRules: (rules: IngressRule[]) => AwsSecurityGroupBuilder;
+  build: () => LiveSystemComponent;
+};
+type AwsSecurityGroupConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description: string;
+  ingressRules?: IngressRule[];
+};
+declare namespace AwsSecurityGroup {
+  const getBuilder: () => AwsSecurityGroupBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedAwsSecurityGroupBuilder;
+  const create: (config: AwsSecurityGroupConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/ec2_instance.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description, dependencies,
+ * links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedEc2Builder = {
+  withAmiId: (amiId: string) => SatisfiedEc2Builder;
+  withInstanceType: (instanceType: string) => SatisfiedEc2Builder;
+  withKeyName: (keyName: string) => SatisfiedEc2Builder;
+  withUserData: (userData: string) => SatisfiedEc2Builder;
+  withIamInstanceProfile: (profile: string) => SatisfiedEc2Builder;
+  withAssociatePublicIp: (associate: boolean) => SatisfiedEc2Builder;
+  build: () => LiveSystemComponent;
+};
+type Ec2InstanceBuilder = {
+  withId: (id: string) => Ec2InstanceBuilder;
+  withVersion: (major: number, minor: number, patch: number) => Ec2InstanceBuilder;
+  withDisplayName: (displayName: string) => Ec2InstanceBuilder;
+  withDescription: (description: string) => Ec2InstanceBuilder;
+  withAmiId: (amiId: string) => Ec2InstanceBuilder;
+  withInstanceType: (instanceType: string) => Ec2InstanceBuilder;
+  withKeyName: (keyName: string) => Ec2InstanceBuilder;
+  withUserData: (userData: string) => Ec2InstanceBuilder;
+  withIamInstanceProfile: (profile: string) => Ec2InstanceBuilder;
+  withAssociatePublicIp: (associate: boolean) => Ec2InstanceBuilder;
+  build: () => LiveSystemComponent;
+};
+type Ec2InstanceConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  amiId: string;
+  instanceType: string;
+  keyName?: string;
+  userData?: string;
+  iamInstanceProfile?: string;
+  associatePublicIp?: boolean;
+};
+declare namespace Ec2Instance {
+  const getBuilder: () => Ec2InstanceBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedEc2Builder;
+  const create: (config: Ec2InstanceConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/azure_vnet.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description, cidrBlock,
+ * dependencies, links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedAzureVnetBuilder = {
+  withLocation: (location: string) => SatisfiedAzureVnetBuilder;
+  withResourceGroup: (rg: string) => SatisfiedAzureVnetBuilder;
+  build: () => LiveSystemComponent;
+};
+type AzureVnetBuilder = {
+  withId: (id: string) => AzureVnetBuilder;
+  withVersion: (major: number, minor: number, patch: number) => AzureVnetBuilder;
+  withDisplayName: (displayName: string) => AzureVnetBuilder;
+  withDescription: (description: string) => AzureVnetBuilder;
+  withCidrBlock: (cidrBlock: string) => AzureVnetBuilder;
+  withLocation: (location: string) => AzureVnetBuilder;
+  withResourceGroup: (rg: string) => AzureVnetBuilder;
+  build: () => LiveSystemComponent;
+};
+type AzureVnetConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  cidrBlock: string;
+  location: string;
+  resourceGroup: string;
+};
+declare namespace AzureVnet {
+  const getBuilder: () => AzureVnetBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedAzureVnetBuilder;
+  const create: (config: AzureVnetConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/azure_subnet.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description, cidrBlock,
+ * dependencies, links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedAzureSubnetBuilder = {
+  withResourceGroup: (rg: string) => SatisfiedAzureSubnetBuilder;
+  build: () => LiveSystemComponent;
+};
+type AzureSubnetBuilder = {
+  withId: (id: string) => AzureSubnetBuilder;
+  withVersion: (major: number, minor: number, patch: number) => AzureSubnetBuilder;
+  withDisplayName: (displayName: string) => AzureSubnetBuilder;
+  withDescription: (description: string) => AzureSubnetBuilder;
+  withCidrBlock: (cidrBlock: string) => AzureSubnetBuilder;
+  withResourceGroup: (rg: string) => AzureSubnetBuilder;
+  build: () => LiveSystemComponent;
+};
+type AzureSubnetConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  cidrBlock: string;
+  resourceGroup: string;
+};
+declare namespace AzureSubnet {
+  const getBuilder: () => AzureSubnetBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedAzureSubnetBuilder;
+  const create: (config: AzureSubnetConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/azure_nsg.d.ts
+/**
+ * Returned by satisfy() — structural properties (id, version, displayName,
+ * description, dependencies, links, ingressRules) are locked to the blueprint
+ * and cannot be overridden.
+ */
+type SatisfiedAzureNsgBuilder = {
+  withLocation: (location: string) => SatisfiedAzureNsgBuilder;
+  withResourceGroup: (rg: string) => SatisfiedAzureNsgBuilder;
+  build: () => LiveSystemComponent;
+};
+type AzureNsgBuilder = {
+  withId: (id: string) => AzureNsgBuilder;
+  withVersion: (major: number, minor: number, patch: number) => AzureNsgBuilder;
+  withDisplayName: (displayName: string) => AzureNsgBuilder;
+  withDescription: (description: string) => AzureNsgBuilder;
+  withIngressRules: (rules: IngressRule[]) => AzureNsgBuilder;
+  withLocation: (location: string) => AzureNsgBuilder;
+  withResourceGroup: (rg: string) => AzureNsgBuilder;
+  build: () => LiveSystemComponent;
+};
+type AzureNsgConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  ingressRules?: IngressRule[];
+  location: string;
+  resourceGroup: string;
+};
+declare namespace AzureNsg {
+  const getBuilder: () => AzureNsgBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedAzureNsgBuilder;
+  const create: (config: AzureNsgConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/azure_vm.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description, dependencies,
+ * links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedAzureVmBuilder = {
+  withVmSize: (vmSize: string) => SatisfiedAzureVmBuilder;
+  withLocation: (location: string) => SatisfiedAzureVmBuilder;
+  withResourceGroup: (rg: string) => SatisfiedAzureVmBuilder;
+  withAdminUsername: (username: string) => SatisfiedAzureVmBuilder;
+  withImagePublisher: (publisher: string) => SatisfiedAzureVmBuilder;
+  withImageOffer: (offer: string) => SatisfiedAzureVmBuilder;
+  withImageSku: (sku: string) => SatisfiedAzureVmBuilder;
+  withSshPublicKey: (key: string) => SatisfiedAzureVmBuilder;
+  withOsDiskSizeGb: (gb: number) => SatisfiedAzureVmBuilder;
+  build: () => LiveSystemComponent;
+};
+type AzureVmBuilder = {
+  withId: (id: string) => AzureVmBuilder;
+  withVersion: (major: number, minor: number, patch: number) => AzureVmBuilder;
+  withDisplayName: (displayName: string) => AzureVmBuilder;
+  withDescription: (description: string) => AzureVmBuilder;
+  withVmSize: (vmSize: string) => AzureVmBuilder;
+  withLocation: (location: string) => AzureVmBuilder;
+  withResourceGroup: (rg: string) => AzureVmBuilder;
+  withAdminUsername: (username: string) => AzureVmBuilder;
+  withImagePublisher: (publisher: string) => AzureVmBuilder;
+  withImageOffer: (offer: string) => AzureVmBuilder;
+  withImageSku: (sku: string) => AzureVmBuilder;
+  withSshPublicKey: (key: string) => AzureVmBuilder;
+  withOsDiskSizeGb: (gb: number) => AzureVmBuilder;
+  build: () => LiveSystemComponent;
+};
+type AzureVmConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  vmSize: string;
+  location: string;
+  resourceGroup: string;
+  adminUsername: string;
+  imagePublisher: string;
+  imageOffer: string;
+  imageSku: string;
+  sshPublicKey?: string;
+  osDiskSizeGb?: number;
+};
+declare namespace AzureVm {
+  const getBuilder: () => AzureVmBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedAzureVmBuilder;
+  const create: (config: AzureVmConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/gcp_vpc.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description, cidrBlock,
+ * dependencies, links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedGcpVpcBuilder = {
+  withAutoCreateSubnetworks: (enabled: boolean) => SatisfiedGcpVpcBuilder;
+  withRoutingMode: (mode: 'REGIONAL' | 'GLOBAL') => SatisfiedGcpVpcBuilder;
+  build: () => LiveSystemComponent;
+};
+type GcpVpcBuilder = {
+  withId: (id: string) => GcpVpcBuilder;
+  withVersion: (major: number, minor: number, patch: number) => GcpVpcBuilder;
+  withDisplayName: (displayName: string) => GcpVpcBuilder;
+  withDescription: (description: string) => GcpVpcBuilder;
+  withCidrBlock: (cidrBlock: string) => GcpVpcBuilder;
+  withAutoCreateSubnetworks: (enabled: boolean) => GcpVpcBuilder;
+  withRoutingMode: (mode: 'REGIONAL' | 'GLOBAL') => GcpVpcBuilder;
+  build: () => LiveSystemComponent;
+};
+type GcpVpcConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  cidrBlock: string;
+  autoCreateSubnetworks?: boolean;
+  routingMode?: 'REGIONAL' | 'GLOBAL';
+};
+declare namespace GcpVpc {
+  const getBuilder: () => GcpVpcBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedGcpVpcBuilder;
+  const create: (config: GcpVpcConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/gcp_subnet.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description, cidrBlock,
+ * dependencies, links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedGcpSubnetBuilder = {
+  withRegion: (region: string) => SatisfiedGcpSubnetBuilder;
+  withPrivateIpGoogleAccess: (enabled: boolean) => SatisfiedGcpSubnetBuilder;
+  build: () => LiveSystemComponent;
+};
+type GcpSubnetBuilder = {
+  withId: (id: string) => GcpSubnetBuilder;
+  withVersion: (major: number, minor: number, patch: number) => GcpSubnetBuilder;
+  withDisplayName: (displayName: string) => GcpSubnetBuilder;
+  withDescription: (description: string) => GcpSubnetBuilder;
+  withCidrBlock: (cidrBlock: string) => GcpSubnetBuilder;
+  withRegion: (region: string) => GcpSubnetBuilder;
+  withPrivateIpGoogleAccess: (enabled: boolean) => GcpSubnetBuilder;
+  build: () => LiveSystemComponent;
+};
+type GcpSubnetConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  cidrBlock: string;
+  region: string;
+  privateIpGoogleAccess?: boolean;
+};
+declare namespace GcpSubnet {
+  const getBuilder: () => GcpSubnetBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedGcpSubnetBuilder;
+  const create: (config: GcpSubnetConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/gcp_firewall.d.ts
+/**
+ * Returned by satisfy() — structural properties (id, version, displayName,
+ * description, dependencies, links, ingressRules) are locked to the blueprint
+ * and cannot be overridden.
+ */
+type SatisfiedGcpFirewallBuilder = {
+  build: () => LiveSystemComponent;
+};
+type GcpFirewallBuilder = {
+  withId: (id: string) => GcpFirewallBuilder;
+  withVersion: (major: number, minor: number, patch: number) => GcpFirewallBuilder;
+  withDisplayName: (displayName: string) => GcpFirewallBuilder;
+  withDescription: (description: string) => GcpFirewallBuilder;
+  withIngressRules: (rules: IngressRule[]) => GcpFirewallBuilder;
+  build: () => LiveSystemComponent;
+};
+type GcpFirewallConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  ingressRules?: IngressRule[];
+};
+declare namespace GcpFirewall {
+  const getBuilder: () => GcpFirewallBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedGcpFirewallBuilder;
+  const create: (config: GcpFirewallConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/gcp_vm.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description, dependencies,
+ * links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedGcpVmBuilder = {
+  withMachineType: (machineType: string) => SatisfiedGcpVmBuilder;
+  withZone: (zone: string) => SatisfiedGcpVmBuilder;
+  withImageProject: (project: string) => SatisfiedGcpVmBuilder;
+  withImageFamily: (family: string) => SatisfiedGcpVmBuilder;
+  withServiceAccountEmail: (email: string) => SatisfiedGcpVmBuilder;
+  build: () => LiveSystemComponent;
+};
+type GcpVmBuilder = {
+  withId: (id: string) => GcpVmBuilder;
+  withVersion: (major: number, minor: number, patch: number) => GcpVmBuilder;
+  withDisplayName: (displayName: string) => GcpVmBuilder;
+  withDescription: (description: string) => GcpVmBuilder;
+  withMachineType: (machineType: string) => GcpVmBuilder;
+  withZone: (zone: string) => GcpVmBuilder;
+  withImageProject: (project: string) => GcpVmBuilder;
+  withImageFamily: (family: string) => GcpVmBuilder;
+  withServiceAccountEmail: (email: string) => GcpVmBuilder;
+  build: () => LiveSystemComponent;
+};
+type GcpVmConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  machineType: string;
+  zone: string;
+  imageProject: string;
+  imageFamily?: string;
+  serviceAccountEmail?: string;
+};
+declare namespace GcpVm {
+  const getBuilder: () => GcpVmBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedGcpVmBuilder;
+  const create: (config: GcpVmConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/oci_vcn.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description, cidrBlock,
+ * dependencies, links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedOciVcnBuilder = {
+  withCompartmentId: (id: string) => SatisfiedOciVcnBuilder;
+  build: () => LiveSystemComponent;
+};
+type OciVcnBuilder = {
+  withId: (id: string) => OciVcnBuilder;
+  withVersion: (major: number, minor: number, patch: number) => OciVcnBuilder;
+  withDisplayName: (displayName: string) => OciVcnBuilder;
+  withDescription: (description: string) => OciVcnBuilder;
+  withCidrBlock: (cidrBlock: string) => OciVcnBuilder;
+  withCompartmentId: (id: string) => OciVcnBuilder;
+  build: () => LiveSystemComponent;
+};
+type OciVcnConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  cidrBlock: string;
+  compartmentId: string;
+};
+declare namespace OciVcn {
+  const getBuilder: () => OciVcnBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedOciVcnBuilder;
+  const create: (config: OciVcnConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/oci_subnet.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description, cidrBlock,
+ * dependencies, links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedOciSubnetBuilder = {
+  withCompartmentId: (id: string) => SatisfiedOciSubnetBuilder;
+  withAvailabilityDomain: (ad: string) => SatisfiedOciSubnetBuilder;
+  withProhibitPublicIpOnVnic: (prohibit: boolean) => SatisfiedOciSubnetBuilder;
+  build: () => LiveSystemComponent;
+};
+type OciSubnetBuilder = {
+  withId: (id: string) => OciSubnetBuilder;
+  withVersion: (major: number, minor: number, patch: number) => OciSubnetBuilder;
+  withDisplayName: (displayName: string) => OciSubnetBuilder;
+  withDescription: (description: string) => OciSubnetBuilder;
+  withCidrBlock: (cidrBlock: string) => OciSubnetBuilder;
+  withCompartmentId: (id: string) => OciSubnetBuilder;
+  withAvailabilityDomain: (ad: string) => OciSubnetBuilder;
+  withProhibitPublicIpOnVnic: (prohibit: boolean) => OciSubnetBuilder;
+  build: () => LiveSystemComponent;
+};
+type OciSubnetConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  cidrBlock: string;
+  compartmentId: string;
+  availabilityDomain?: string;
+  prohibitPublicIpOnVnic?: boolean;
+};
+declare namespace OciSubnet {
+  const getBuilder: () => OciSubnetBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedOciSubnetBuilder;
+  const create: (config: OciSubnetConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/oci_security_list.d.ts
+/**
+ * Returned by satisfy() — structural properties (id, version, displayName,
+ * description, dependencies, links, ingressRules) are locked to the blueprint
+ * and cannot be overridden.
+ */
+type SatisfiedOciSecurityListBuilder = {
+  withCompartmentId: (id: string) => SatisfiedOciSecurityListBuilder;
+  build: () => LiveSystemComponent;
+};
+type OciSecurityListBuilder = {
+  withId: (id: string) => OciSecurityListBuilder;
+  withVersion: (major: number, minor: number, patch: number) => OciSecurityListBuilder;
+  withDisplayName: (displayName: string) => OciSecurityListBuilder;
+  withDescription: (description: string) => OciSecurityListBuilder;
+  withIngressRules: (rules: IngressRule[]) => OciSecurityListBuilder;
+  withCompartmentId: (id: string) => OciSecurityListBuilder;
+  build: () => LiveSystemComponent;
+};
+type OciSecurityListConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  ingressRules?: IngressRule[];
+  compartmentId: string;
+};
+declare namespace OciSecurityList {
+  const getBuilder: () => OciSecurityListBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedOciSecurityListBuilder;
+  const create: (config: OciSecurityListConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/oci_instance.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description,
+ * dependencies, links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedOciInstanceBuilder = {
+  withCompartmentId: (id: string) => SatisfiedOciInstanceBuilder;
+  withAvailabilityDomain: (ad: string) => SatisfiedOciInstanceBuilder;
+  withShape: (shape: string) => SatisfiedOciInstanceBuilder;
+  withImageId: (imageId: string) => SatisfiedOciInstanceBuilder;
+  withOcpus: (ocpus: number) => SatisfiedOciInstanceBuilder;
+  withMemoryInGbs: (gb: number) => SatisfiedOciInstanceBuilder;
+  withSshPublicKey: (key: string) => SatisfiedOciInstanceBuilder;
+  build: () => LiveSystemComponent;
+};
+type OciInstanceBuilder = {
+  withId: (id: string) => OciInstanceBuilder;
+  withVersion: (major: number, minor: number, patch: number) => OciInstanceBuilder;
+  withDisplayName: (displayName: string) => OciInstanceBuilder;
+  withDescription: (description: string) => OciInstanceBuilder;
+  withCompartmentId: (id: string) => OciInstanceBuilder;
+  withAvailabilityDomain: (ad: string) => OciInstanceBuilder;
+  withShape: (shape: string) => OciInstanceBuilder;
+  withImageId: (imageId: string) => OciInstanceBuilder;
+  withOcpus: (ocpus: number) => OciInstanceBuilder;
+  withMemoryInGbs: (gb: number) => OciInstanceBuilder;
+  withSshPublicKey: (key: string) => OciInstanceBuilder;
+  build: () => LiveSystemComponent;
+};
+type OciInstanceConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  compartmentId: string;
+  availabilityDomain: string;
+  shape: string;
+  imageId: string;
+  ocpus?: number;
+  memoryInGbs?: number;
+  sshPublicKey?: string;
+};
+declare namespace OciInstance {
+  const getBuilder: () => OciInstanceBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedOciInstanceBuilder;
+  const create: (config: OciInstanceConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/hetzner_network.d.ts
+/**
+ * Returned by satisfy() — structural properties (id, version, displayName,
+ * description, cidrBlock, dependencies, links) are locked to the blueprint
+ * and cannot be overridden.
+ */
+type SatisfiedHetznerNetworkBuilder = {
+  build: () => LiveSystemComponent;
+};
+type HetznerNetworkBuilder = {
+  withId: (id: string) => HetznerNetworkBuilder;
+  withVersion: (major: number, minor: number, patch: number) => HetznerNetworkBuilder;
+  withDisplayName: (displayName: string) => HetznerNetworkBuilder;
+  withDescription: (description: string) => HetznerNetworkBuilder;
+  withCidrBlock: (cidrBlock: string) => HetznerNetworkBuilder;
+  build: () => LiveSystemComponent;
+};
+type HetznerNetworkConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  cidrBlock: string;
+};
+declare namespace HetznerNetwork {
+  const getBuilder: () => HetznerNetworkBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedHetznerNetworkBuilder;
+  const create: (config: HetznerNetworkConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/hetzner_subnet.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description, cidrBlock,
+ * dependencies, links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedHetznerSubnetBuilder = {
+  withNetworkZone: (zone: string) => SatisfiedHetznerSubnetBuilder;
+  withType: (type: string) => SatisfiedHetznerSubnetBuilder;
+  build: () => LiveSystemComponent;
+};
+type HetznerSubnetBuilder = {
+  withId: (id: string) => HetznerSubnetBuilder;
+  withVersion: (major: number, minor: number, patch: number) => HetznerSubnetBuilder;
+  withDisplayName: (displayName: string) => HetznerSubnetBuilder;
+  withDescription: (description: string) => HetznerSubnetBuilder;
+  withCidrBlock: (cidrBlock: string) => HetznerSubnetBuilder;
+  withNetworkZone: (zone: string) => HetznerSubnetBuilder;
+  withType: (type: string) => HetznerSubnetBuilder;
+  build: () => LiveSystemComponent;
+};
+type HetznerSubnetConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  cidrBlock: string;
+  networkZone: string;
+  type?: string;
+};
+declare namespace HetznerSubnet {
+  const getBuilder: () => HetznerSubnetBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedHetznerSubnetBuilder;
+  const create: (config: HetznerSubnetConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/hetzner_firewall.d.ts
+/**
+ * Returned by satisfy() — structural properties (id, version, displayName,
+ * description, dependencies, links, ingressRules) are locked to the blueprint
+ * and cannot be overridden.
+ */
+type SatisfiedHetznerFirewallBuilder = {
+  build: () => LiveSystemComponent;
+};
+type HetznerFirewallBuilder = {
+  withId: (id: string) => HetznerFirewallBuilder;
+  withVersion: (major: number, minor: number, patch: number) => HetznerFirewallBuilder;
+  withDisplayName: (displayName: string) => HetznerFirewallBuilder;
+  withDescription: (description: string) => HetznerFirewallBuilder;
+  withIngressRules: (rules: IngressRule[]) => HetznerFirewallBuilder;
+  build: () => LiveSystemComponent;
+};
+type HetznerFirewallConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  ingressRules?: IngressRule[];
+};
+declare namespace HetznerFirewall {
+  const getBuilder: () => HetznerFirewallBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedHetznerFirewallBuilder;
+  const create: (config: HetznerFirewallConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/iaas/hetzner_server.d.ts
+/**
+ * Returned by satisfy() — only exposes vendor-specific parameters.
+ * Structural properties (id, version, displayName, description,
+ * dependencies, links) are locked to the blueprint and cannot be overridden.
+ */
+type SatisfiedHetznerServerBuilder = {
+  withServerType: (serverType: string) => SatisfiedHetznerServerBuilder;
+  withLocation: (location: string) => SatisfiedHetznerServerBuilder;
+  withImage: (image: string) => SatisfiedHetznerServerBuilder;
+  withSshKeys: (keys: string[]) => SatisfiedHetznerServerBuilder;
+  withUserData: (userData: string) => SatisfiedHetznerServerBuilder;
+  build: () => LiveSystemComponent;
+};
+type HetznerServerBuilder = {
+  withId: (id: string) => HetznerServerBuilder;
+  withVersion: (major: number, minor: number, patch: number) => HetznerServerBuilder;
+  withDisplayName: (displayName: string) => HetznerServerBuilder;
+  withDescription: (description: string) => HetznerServerBuilder;
+  withServerType: (serverType: string) => HetznerServerBuilder;
+  withLocation: (location: string) => HetznerServerBuilder;
+  withImage: (image: string) => HetznerServerBuilder;
+  withSshKeys: (keys: string[]) => HetznerServerBuilder;
+  withUserData: (userData: string) => HetznerServerBuilder;
+  build: () => LiveSystemComponent;
+};
+type HetznerServerConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  serverType: string;
+  location: string;
+  image: string;
+  sshKeys?: string[];
+  userData?: string;
+};
+declare namespace HetznerServer {
+  const getBuilder: () => HetznerServerBuilder;
+  const satisfy: (blueprint: BlueprintComponent) => SatisfiedHetznerServerBuilder;
+  const create: (config: HetznerServerConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/fractal/component/network_and_compute/paas/container_platform.d.ts
+type ContainerPlatformNode = {
+  readonly platform: BlueprintComponent;
+  /**
+   * Workload nodes with the platform dependency auto-wired into each component.
+   * Pass these to Subnet.withWorkloads() so the subnet dep is stacked on top.
+   */
+  readonly workloads: ReadonlyArray<WorkloadNode>;
+  withWorkloads: (workloads: WorkloadNode[]) => ContainerPlatformNode;
+};
+type ContainerPlatformBuilder = {
+  withId: (id: string) => ContainerPlatformBuilder;
+  withVersion: (major: number, minor: number, patch: number) => ContainerPlatformBuilder;
+  withDisplayName: (displayName: string) => ContainerPlatformBuilder;
+  withDescription: (description: string) => ContainerPlatformBuilder;
+  build: () => BlueprintComponent;
+};
+type ContainerPlatformConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+};
+declare namespace ContainerPlatform {
+  const getBuilder: () => ContainerPlatformBuilder;
+  const create: (config: ContainerPlatformConfig) => ContainerPlatformNode;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/paas/ecs_cluster.d.ts
+/**
+ * Returned by satisfy() — id, version, and displayName are locked from the
+ * blueprint ContainerPlatform. No AWS-specific parameters are needed for a
+ * basic ECS cluster, so only build() is exposed.
+ */
+type SatisfiedAwsEcsClusterBuilder = {
+  build: () => LiveSystemComponent;
+};
+type AwsEcsClusterBuilder = {
+  withId: (id: string) => AwsEcsClusterBuilder;
+  withVersion: (major: number, minor: number, patch: number) => AwsEcsClusterBuilder;
+  withDisplayName: (displayName: string) => AwsEcsClusterBuilder;
+  withDescription: (description: string) => AwsEcsClusterBuilder;
+  build: () => LiveSystemComponent;
+};
+type AwsEcsClusterConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+};
+declare namespace AwsEcsCluster {
+  const getBuilder: () => AwsEcsClusterBuilder;
+  /**
+   * Satisfies a blueprint ContainerPlatform component as an AWS ECS Cluster.
+   * Carries id, version, displayName, and description from the blueprint.
+   */
+  const satisfy: (platform: BlueprintComponent) => SatisfiedAwsEcsClusterBuilder;
+  const create: (config: AwsEcsClusterConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/paas/ecs_task_definition.d.ts
+/**
+ * Returned by satisfy() — blueprint params (image, port, cpu, memory) are
+ * locked. Only IAM role ARNs and network mode can be added here.
+ *
+ * The component ID is derived as `${workload.id}-task` to avoid collision
+ * with the AwsEcsService component that satisfies the same blueprint workload.
+ */
+type SatisfiedAwsEcsTaskDefinitionBuilder = {
+  withNetworkMode: (mode: string) => SatisfiedAwsEcsTaskDefinitionBuilder;
+  withExecutionRoleArn: (arn: string) => SatisfiedAwsEcsTaskDefinitionBuilder;
+  withTaskRoleArn: (arn: string) => SatisfiedAwsEcsTaskDefinitionBuilder;
+  build: () => LiveSystemComponent;
+};
+type AwsEcsTaskDefinitionBuilder = {
+  withId: (id: string) => AwsEcsTaskDefinitionBuilder;
+  withVersion: (major: number, minor: number, patch: number) => AwsEcsTaskDefinitionBuilder;
+  withDisplayName: (displayName: string) => AwsEcsTaskDefinitionBuilder;
+  withDescription: (description: string) => AwsEcsTaskDefinitionBuilder;
+  withContainerImage: (image: string) => AwsEcsTaskDefinitionBuilder;
+  withContainerPort: (port: number) => AwsEcsTaskDefinitionBuilder;
+  withContainerName: (name: string) => AwsEcsTaskDefinitionBuilder;
+  withCpu: (cpu: string) => AwsEcsTaskDefinitionBuilder;
+  withMemory: (memory: string) => AwsEcsTaskDefinitionBuilder;
+  withNetworkMode: (mode: string) => AwsEcsTaskDefinitionBuilder;
+  withExecutionRoleArn: (arn: string) => AwsEcsTaskDefinitionBuilder;
+  withTaskRoleArn: (arn: string) => AwsEcsTaskDefinitionBuilder;
+  build: () => LiveSystemComponent;
+};
+type AwsEcsTaskDefinitionConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  containerImage: string;
+  containerPort?: number;
+  containerName?: string;
+  cpu?: string;
+  memory?: string;
+  networkMode?: string;
+  executionRoleArn?: string;
+  taskRoleArn?: string;
+};
+declare namespace AwsEcsTaskDefinition {
+  const getBuilder: () => AwsEcsTaskDefinitionBuilder;
+  /**
+   * Satisfies a blueprint Workload component as an AWS ECS Task Definition.
+   * The component ID is `${workload.id}-task` to avoid collision with the
+   * AwsEcsService that satisfies the same workload.
+   */
+  const satisfy: (workload: BlueprintComponent) => SatisfiedAwsEcsTaskDefinitionBuilder;
+  const create: (config: AwsEcsTaskDefinitionConfig) => LiveSystemComponent;
+}
+//#endregion
+//#region src/live_system/component/network_and_compute/paas/ecs_service.d.ts
+/**
+ * Returned by satisfy() — all structural properties (dependencies, links,
+ * desiredCount) are locked from the blueprint. Only AWS-specific launch
+ * parameters are set here.
+ */
+type SatisfiedAwsEcsServiceBuilder = {
+  withLaunchType: (type: string) => SatisfiedAwsEcsServiceBuilder;
+  withAssignPublicIp: (assign: boolean) => SatisfiedAwsEcsServiceBuilder;
+  build: () => LiveSystemComponent;
+};
+type AwsEcsServiceBuilder = {
+  withId: (id: string) => AwsEcsServiceBuilder;
+  withVersion: (major: number, minor: number, patch: number) => AwsEcsServiceBuilder;
+  withDisplayName: (displayName: string) => AwsEcsServiceBuilder;
+  withDescription: (description: string) => AwsEcsServiceBuilder;
+  withDesiredCount: (count: number) => AwsEcsServiceBuilder;
+  withLaunchType: (type: string) => AwsEcsServiceBuilder;
+  withAssignPublicIp: (assign: boolean) => AwsEcsServiceBuilder;
+  build: () => LiveSystemComponent;
+};
+type AwsEcsServiceConfig = {
+  id: string;
+  version: {
+    major: number;
+    minor: number;
+    patch: number;
+  };
+  displayName: string;
+  description?: string;
+  desiredCount?: number;
+  launchType?: string;
+  assignPublicIp?: boolean;
+};
+declare namespace AwsEcsService {
+  const getBuilder: () => AwsEcsServiceBuilder;
+  /**
+   * Satisfies a blueprint Workload component as an AWS ECS Service.
+   * All structural properties — dependencies (subnet, cluster), links
+   * (traffic rules, SG membership), and desiredCount — are carried from
+   * the blueprint unchanged. Only AWS-specific launch parameters are added here.
+   */
+  const satisfy: (workload: BlueprintComponent) => SatisfiedAwsEcsServiceBuilder;
+  const create: (config: AwsEcsServiceConfig) => LiveSystemComponent;
+}
+//#endregion
 //#region src/index.d.ts
 declare const BoundedContext: typeof BoundedContext$1;
 type BoundedContext = BoundedContext$1;
@@ -1172,5 +2820,9 @@ 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, Fractal, InfrastructureDomain, KebabCaseString, OwnerId, OwnerType, PascalCaseString, ServiceAccountCredentials, ServiceAccountId, ServiceDeliveryModel, Version };
+export { AwsEcsCluster, type AwsEcsClusterBuilder, type AwsEcsClusterConfig, AwsEcsService, type AwsEcsServiceBuilder, type AwsEcsServiceConfig, AwsEcsTaskDefinition, type AwsEcsTaskDefinitionBuilder, type AwsEcsTaskDefinitionConfig, AwsSecurityGroup, type AwsSecurityGroupBuilder, type AwsSecurityGroupConfig, AwsSubnet, type AwsSubnetBuilder, type AwsSubnetConfig, AwsVpc, type AwsVpcBuilder, type AwsVpcConfig, AzureNsg, type AzureNsgBuilder, type AzureNsgConfig, AzureSubnet, type AzureSubnetBuilder, type AzureSubnetConfig, AzureVm, type AzureVmBuilder, type AzureVmConfig, AzureVnet, type AzureVnetBuilder, type AzureVnetConfig, BoundedContext, ContainerPlatform, type ContainerPlatformBuilder, type ContainerPlatformConfig, type ContainerPlatformNode, Ec2Instance, type Ec2InstanceBuilder, type Ec2InstanceConfig, Environment, Fractal, GcpFirewall, type GcpFirewallBuilder, type GcpFirewallConfig, GcpSubnet, type GcpSubnetBuilder, type GcpSubnetConfig, GcpVm, type GcpVmBuilder, type GcpVmConfig, GcpVpc, type GcpVpcBuilder, type GcpVpcConfig, HetznerFirewall, type HetznerFirewallBuilder, type HetznerFirewallConfig, HetznerNetwork, type HetznerNetworkBuilder, type HetznerNetworkConfig, HetznerServer, type HetznerServerBuilder, type HetznerServerConfig, HetznerSubnet, type HetznerSubnetBuilder, type HetznerSubnetConfig, InfrastructureDomain, type IngressRule, KebabCaseString, LiveSystem, OciInstance, type OciInstanceBuilder, type OciInstanceConfig, OciSecurityList, type OciSecurityListBuilder, type OciSecurityListConfig, OciSubnet, type OciSubnetBuilder, type OciSubnetConfig, OciVcn, type OciVcnBuilder, type OciVcnConfig, OwnerId, OwnerType, PascalCaseString, type SatisfiedAwsEcsClusterBuilder, type SatisfiedAwsEcsServiceBuilder, type SatisfiedAwsEcsTaskDefinitionBuilder, type SatisfiedAwsSecurityGroupBuilder, type SatisfiedAwsSubnetBuilder, type SatisfiedAwsVpcBuilder, type SatisfiedAzureNsgBuilder, type SatisfiedAzureSubnetBuilder, type SatisfiedAzureVmBuilder, type SatisfiedAzureVnetBuilder, type SatisfiedEc2Builder, type SatisfiedGcpFirewallBuilder, type SatisfiedGcpSubnetBuilder, type SatisfiedGcpVmBuilder, type SatisfiedGcpVpcBuilder, type SatisfiedHetznerFirewallBuilder, type SatisfiedHetznerNetworkBuilder, type SatisfiedHetznerServerBuilder, type SatisfiedHetznerSubnetBuilder, type SatisfiedOciInstanceBuilder, type SatisfiedOciSecurityListBuilder, type SatisfiedOciSubnetBuilder, type SatisfiedOciVcnBuilder, SecurityGroup, type SecurityGroupBuilder, type SecurityGroupConfig, ServiceAccountCredentials, ServiceAccountId, ServiceDeliveryModel, Subnet, type SubnetBuilder, type SubnetConfig, type SubnetNode, type SubnetResult, Version, VirtualMachine, type VirtualMachineBuilder, type VirtualMachineConfig, type VirtualMachineNode, VirtualNetwork, type VirtualNetworkBuilder, type VirtualNetworkConfig, type VirtualNetworkNode, type VirtualNetworkResult, type VmPortLink, Workload, type WorkloadBuilder, type WorkloadConfig, type WorkloadNode, type WorkloadPortLink };