@fractal_cloud/sdk 0.1.2 → 1.0.0

package/dist/index.d.cts

@@ -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,384 @@ 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/index.d.ts
 declare const BoundedContext: typeof BoundedContext$1;
 type BoundedContext = BoundedContext$1;
@@ -1172,5 +1617,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 { BoundedContext, Environment, Fractal, InfrastructureDomain, KebabCaseString, LiveSystem, OwnerId, OwnerType, PascalCaseString, ServiceAccountCredentials, ServiceAccountId, ServiceDeliveryModel, Version };