@fractal_cloud/sdk 1.5.2 → 2.0.0

package/dist/model/index.d.cts

@@ -0,0 +1,767 @@
+//#region src/model/core.d.ts
+/**
+ * core.ts — the LOCKED Fractal model engine (see docs/fractal-model.md).
+ *
+ * Shared by every Component factory (src/model/components/*) and Offer catalogue
+ * (src/model/offers/*). This is the canonical engine; the catalogue and the
+ * model specs (src/model/*.test.ts) build on it.
+ *
+ * Decisions encoded here:
+ *   - Fractal is vendor-agnostic: blueprints reference abstract Components only;
+ *     offers come from the open Catalogue at LiveSystem time.
+ *   - Offers carry their own vendor config and declare which Component they satisfy.
+ *   - Agnostic params are typed `.withXxx()` setters on Component factories;
+ *     called at design time they are GUARDRAILS (locked; devs cannot override).
+ *   - Specialization is pure transforms with an immutable fluent `.specialize()`.
+ *   - A LiveSystem is built EXCLUSIVELY by per-component offer selection
+ *     (`select`), with no global provider; mixed vendors are normal.
+ */
+type Provider = 'AWS' | 'Azure' | 'GCP' | 'OCI' | 'Hetzner' | 'Aruba' | 'RedHat' | 'VMware';
+type DeliveryModel = 'IaaS' | 'PaaS' | 'CaaS' | 'SaaS' | 'FaaS';
+/**
+ * A runtime relationship to another component, on the agent wire contract:
+ * `{componentId, settings}`. The agent resolves the target by `componentId` and
+ * reads `settings` (e.g. fromPort/protocol for traffic rules; empty for security
+ * group / network-policy membership).
+ */
+type ComponentLink = {
+  componentId: string;
+  settings: Record<string, unknown>;
+};
+/** A child component added under a parent via an application operation (e.g. a
+ *  database under a DBMS). The parent offer's `instantiate` emits a live
+ *  component for each child IN ITS OWN VENDOR FAMILY — children are not
+ *  independently offer-selected; swapping the parent offer swaps the family. */
+type ChildContext = {
+  id: string;
+  parameters: Record<string, unknown>;
+  dependencies: readonly string[];
+  links: readonly ComponentLink[];
+};
+type InstantiationContext = {
+  id: string;
+  parameters: Record<string, unknown>;
+  dependencies: readonly string[];
+  links: readonly ComponentLink[]; /** Child components the application added under this component. */
+  children: readonly ChildContext[];
+};
+type LiveSystemComponent = {
+  id: string;
+  type: string;
+  provider?: Provider;
+  deliveryModel: DeliveryModel;
+  parameters: Record<string, unknown>;
+  dependencies: readonly string[];
+  links: readonly ComponentLink[];
+};
+type Offer<C extends string = string, Cfg = unknown> = {
+  readonly satisfies: C;
+  readonly offerType: string;
+  readonly provider?: Provider;
+  readonly deliveryModel: DeliveryModel;
+  readonly config: Cfg;
+  readonly instantiate: (ctx: InstantiationContext) => LiveSystemComponent[];
+};
+/** Build an offer constructor (pure). Default instantiate merges neutral params + vendor config. */
+declare const defineOffer: <C extends string, Cfg>(spec: {
+  satisfies: C;
+  offerType: string;
+  provider?: Provider;
+  deliveryModel: DeliveryModel;
+  instantiate?: (ctx: InstantiationContext, config: Cfg) => LiveSystemComponent[];
+}) => (config: Cfg) => Offer<C, Cfg>;
+type NodeState = {
+  readonly id: string;
+  readonly component: string;
+  readonly parameters: Readonly<Record<string, unknown>>;
+  readonly locked: ReadonlySet<string>;
+  readonly dependencies: readonly string[];
+};
+/**
+ * A blueprint component node. `Id` and `Component` literals are phantom types
+ * (never present at runtime) so `toLiveSystem({select})` is type-checked: each
+ * component id maps to the Component it requires, and the selected offer must
+ * satisfy that Component.
+ */
+type ComponentNode<Id extends string = string, Component extends string = string> = {
+  readonly state: NodeState;
+  readonly __id?: Id;
+  readonly __component?: Component;
+};
+type AnyNode = ComponentNode;
+/** Authoring primitive: create a fresh node for a Component factory. */
+declare const newNode: (id: string, component: string) => NodeState;
+/** Authoring primitive: set a neutral param AND lock it (guardrail, design time). */
+declare const guardrail: (s: NodeState, key: string, value: unknown) => NodeState;
+/** Authoring primitive: declare a structural dependency on another node. */
+declare const addDependency: (s: NodeState, depId: string) => NodeState;
+/** A link authored in the blueprint: source component → target component + settings. */
+type LinkRecord = {
+  sourceId: string;
+  targetId: string;
+  settings: Record<string, unknown>;
+};
+type FractalState = {
+  readonly fractalId: string;
+  readonly fractalName: string;
+  readonly version: Version;
+  readonly boundedContext: OwnerRef;
+  readonly nodes: Readonly<Record<string, NodeState>>;
+  readonly order: readonly string[];
+  readonly links: readonly LinkRecord[]; /** Child component nodes added via operations, keyed by parent component id. */
+  readonly children: Readonly<Record<string, readonly NodeState[]>>;
+};
+type Transform = (st: FractalState) => FractalState;
+/** Dev-facing handle exposed to the `operations` author; produces pure transforms. */
+type SlotOps = {
+  set: (key: string, value: unknown) => Transform;
+  append: (key: string, value: unknown) => Transform;
+  /**
+   * Add a child component under this component (e.g. a database under a DBMS).
+   * The child is emitted by the PARENT's selected offer, in the parent's vendor
+   * family — no separate offer selection. Swapping the parent offer swaps the
+   * child's family too. The child depends on this parent.
+   */
+  addChild: (child: AnyNode) => Transform;
+};
+type SerializedComponent = {
+  id: string;
+  component: string;
+  parameters: Record<string, unknown>;
+  locked: string[];
+  dependencies: string[];
+  links: ComponentLink[];
+};
+type Blueprint = {
+  fractalId: string;
+  components: SerializedComponent[];
+};
+/** Owner-scoped reference (Bounded Context / Environment). Fields optional so
+ *  non-deploying tests can omit owner identity; deploy validates them. */
+type OwnerRef = {
+  ownerType?: string;
+  ownerId?: string;
+  name?: string;
+};
+type Version = {
+  major: number;
+  minor: number;
+  patch: number;
+};
+type LiveSystem = {
+  name: string;
+  fractalId: string;
+  fractalName: string;
+  version: Version;
+  boundedContext: OwnerRef;
+  environment: OwnerRef;
+  components: LiveSystemComponent[];
+};
+type ToLiveSystemArgs = {
+  name: string;
+  environment: OwnerRef; /** Per-component offer selection. Key = component id. */
+  select: Record<string, Offer>;
+};
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+/** From the blueprint slots, derive `{ [componentId]: ComponentTag }`. */
+type IdToComponent<Slots> = UnionToIntersection<{ [K in keyof Slots]: Slots[K] extends ComponentNode<infer Id, infer Component> ? { [P in Id]: Component } : never }[keyof Slots]>;
+/** Each component id requires an offer that satisfies that id's Component. */
+type Selection<Slots> = { [Id in keyof IdToComponent<Slots>]: Offer<IdToComponent<Slots>[Id] & string> };
+type TypedToLiveSystemArgs<Slots> = {
+  name: string;
+  environment: OwnerRef;
+  select: Selection<Slots>;
+};
+type OpFactories = Record<string, (...args: never[]) => Transform>;
+type Specialized<Slots, Ops extends OpFactories> = { [K in keyof Ops]: (...args: Parameters<Ops[K]>) => Specialized<Slots, Ops> } & {
+  readonly value: FractalState;
+  readonly blueprint: Blueprint;
+  toLiveSystem: (args: TypedToLiveSystemArgs<Slots>) => LiveSystem;
+};
+type Fractal<Slots, Ops extends OpFactories> = {
+  readonly fractalId: string;
+  readonly blueprint: Blueprint;
+  readonly ops: Ops;
+  specialize: () => Specialized<Slots, Ops>;
+  toLiveSystem: (args: TypedToLiveSystemArgs<Slots>) => LiveSystem;
+};
+declare function createFractal<Slots extends Record<string, AnyNode>, Ops extends OpFactories>(def: {
+  id: string;
+  version: Version;
+  boundedContextId: OwnerRef;
+  description?: string;
+  blueprint: (bp: {
+    add: <N extends AnyNode>(n: N) => N;
+    /**
+     * Declare a runtime link: `source` links to `target` with optional settings
+     * (e.g. {fromPort, protocol} for a traffic rule; empty for security-group /
+     * network-policy membership). Blueprint owns all links — see docs/fractal-model.md.
+     */
+    link: (source: AnyNode, target: AnyNode, settings?: Record<string, unknown>) => void;
+  }) => Slots;
+  operations?: (slots: { [K in keyof Slots]: SlotOps }) => Ops;
+}): Fractal<Slots, Ops>;
+//#endregion
+//#region src/model/service.d.ts
+type Credentials = {
+  clientId: string;
+  clientSecret: string;
+};
+type DeployOptions = {
+  mode: 'wait' | 'fire-and-forget';
+  quiet?: boolean;
+  pollIntervalMs?: number;
+  timeoutMs?: number;
+};
+/** Deploy (create or update) a LiveSystem. `fire-and-forget` submits and returns;
+ *  `wait` polls until Active (or failure/timeout) emitting wait-mode log lines. */
+declare function deploy(ls: LiveSystem, creds: Credentials, opts?: DeployOptions): Promise<void>;
+/** Destroy a deployed LiveSystem. */
+declare function destroy(ls: LiveSystem, creds: Credentials): Promise<void>;
+//#endregion
+//#region src/model/components/network_and_compute.d.ts
+type Rule = {
+  protocol?: string;
+  fromPort: number;
+  toPort?: number;
+  sourceCidr?: string;
+};
+type NodePool = {
+  name: string;
+  minNodeCount?: number;
+  maxNodeCount?: number;
+  autoscalingEnabled?: boolean;
+};
+type VirtualNetworkNode<Id extends string = string> = ComponentNode<Id, 'NetworkAndCompute.VirtualNetwork'> & {
+  withCidrBlock: (v: string) => VirtualNetworkNode<Id>;
+  withRegion: (v: string) => VirtualNetworkNode<Id>;
+  withTags: (v: Record<string, string>) => VirtualNetworkNode<Id>;
+};
+declare const VirtualNetwork: <const Id extends string>(cfg: {
+  id: Id;
+}) => VirtualNetworkNode<Id>;
+type SubnetNode<Id extends string = string> = ComponentNode<Id, 'NetworkAndCompute.Subnet'> & {
+  withCidrBlock: (v: string) => SubnetNode<Id>;
+  dependsOn: (other: AnyNode) => SubnetNode<Id>;
+};
+declare const Subnet: <const Id extends string>(cfg: {
+  id: Id;
+}) => SubnetNode<Id>;
+type SecurityGroupNode<Id extends string = string> = ComponentNode<Id, 'NetworkAndCompute.SecurityGroup'> & {
+  withIngressRules: (v: Rule[]) => SecurityGroupNode<Id>;
+  withEgressRules: (v: Rule[]) => SecurityGroupNode<Id>;
+  dependsOn: (other: AnyNode) => SecurityGroupNode<Id>;
+};
+declare const SecurityGroup: <const Id extends string>(cfg: {
+  id: Id;
+}) => SecurityGroupNode<Id>;
+type VirtualMachineNode<Id extends string = string> = ComponentNode<Id, 'NetworkAndCompute.VirtualMachine'> & {
+  withOsType: (v: 'linux' | 'windows') => VirtualMachineNode<Id>;
+  withSize: (v: string) => VirtualMachineNode<Id>;
+  withTags: (v: Record<string, string>) => VirtualMachineNode<Id>;
+  dependsOn: (other: AnyNode) => VirtualMachineNode<Id>;
+};
+declare const VirtualMachine: <const Id extends string>(cfg: {
+  id: Id;
+}) => VirtualMachineNode<Id>;
+type ContainerPlatformNode<Id extends string = string> = ComponentNode<Id, 'NetworkAndCompute.ContainerPlatform'> & {
+  withNodePools: (v: NodePool[]) => ContainerPlatformNode<Id>;
+  withKubernetesVersion: (v: string) => ContainerPlatformNode<Id>;
+  withNetworkPolicyProvider: (v: string) => ContainerPlatformNode<Id>;
+  dependsOn: (other: AnyNode) => ContainerPlatformNode<Id>;
+};
+declare const ContainerPlatform: <const Id extends string>(cfg: {
+  id: Id;
+}) => ContainerPlatformNode<Id>;
+type LoadBalancerNode<Id extends string = string> = ComponentNode<Id, 'NetworkAndCompute.LoadBalancer'> & {
+  withScheme: (v: 'internal' | 'internet-facing') => LoadBalancerNode<Id>;
+  dependsOn: (other: AnyNode) => LoadBalancerNode<Id>;
+};
+declare const LoadBalancer: <const Id extends string>(cfg: {
+  id: Id;
+}) => LoadBalancerNode<Id>;
+//#endregion
+//#region src/model/components/storage.d.ts
+type ObjectStorageNode<Id extends string = string> = ComponentNode<Id, 'Storage.ObjectStorage'> & {
+  withVersioningEnabled: (v: boolean) => ObjectStorageNode<Id>;
+  withStorageClass: (v: string) => ObjectStorageNode<Id>;
+  withPublicAccess: (v: boolean) => ObjectStorageNode<Id>;
+  withEncryption: (v: 'at-rest' | 'none') => ObjectStorageNode<Id>;
+  withRetentionDays: (v: number) => ObjectStorageNode<Id>;
+  withTags: (v: Record<string, string>) => ObjectStorageNode<Id>;
+};
+declare const ObjectStorage: <const Id extends string>(cfg: {
+  id: Id;
+}) => ObjectStorageNode<Id>;
+type RelationalDbmsNode<Id extends string = string> = ComponentNode<Id, 'Storage.RelationalDbms'> & {
+  withEngineVersion: (v: string) => RelationalDbmsNode<Id>;
+  withSizeTier: (v: string) => RelationalDbmsNode<Id>;
+  withStorageGb: (v: number) => RelationalDbmsNode<Id>;
+  withBackupRetentionDays: (v: number) => RelationalDbmsNode<Id>;
+  withHighAvailability: (v: string) => RelationalDbmsNode<Id>;
+};
+declare const RelationalDbms: <const Id extends string>(cfg: {
+  id: Id;
+}) => RelationalDbmsNode<Id>;
+type RelationalDatabaseNode<Id extends string = string> = ComponentNode<Id, 'Storage.RelationalDatabase'> & {
+  withCharset: (v: string) => RelationalDatabaseNode<Id>;
+  withCollation: (v: string) => RelationalDatabaseNode<Id>;
+  dependsOn: (other: AnyNode) => RelationalDatabaseNode<Id>;
+};
+declare const RelationalDatabase: <const Id extends string>(cfg: {
+  id: Id;
+}) => RelationalDatabaseNode<Id>;
+//#endregion
+//#region src/model/components/big_data.d.ts
+type ComputeClusterNode<Id extends string = string> = ComponentNode<Id, 'BigData.ComputeCluster'> & {
+  withClusterName: (v: string) => ComputeClusterNode<Id>;
+  withSparkVersion: (v: string) => ComputeClusterNode<Id>;
+  withMinWorkers: (v: number) => ComputeClusterNode<Id>;
+  withMaxWorkers: (v: number) => ComputeClusterNode<Id>;
+  withAutoTerminationMinutes: (v: number) => ComputeClusterNode<Id>;
+  withDataSecurityMode: (v: string) => ComputeClusterNode<Id>;
+};
+declare const ComputeCluster: <const Id extends string>(cfg: {
+  id: Id;
+}) => ComputeClusterNode<Id>;
+type DataProcessingJobNode<Id extends string = string> = ComponentNode<Id, 'BigData.DataProcessingJob'> & {
+  withJobName: (v: string) => DataProcessingJobNode<Id>;
+  withTaskType: (v: string) => DataProcessingJobNode<Id>;
+  withCronSchedule: (v: string) => DataProcessingJobNode<Id>;
+  withMaxRetries: (v: number) => DataProcessingJobNode<Id>;
+  dependsOn: (other: AnyNode) => DataProcessingJobNode<Id>;
+};
+declare const DataProcessingJob: <const Id extends string>(cfg: {
+  id: Id;
+}) => DataProcessingJobNode<Id>;
+type MlExperimentNode<Id extends string = string> = ComponentNode<Id, 'BigData.MlExperiment'> & {
+  withExperimentName: (v: string) => MlExperimentNode<Id>;
+};
+declare const MlExperiment: <const Id extends string>(cfg: {
+  id: Id;
+}) => MlExperimentNode<Id>;
+type DatalakeNode<Id extends string = string> = ComponentNode<Id, 'BigData.Datalake'> & {
+  withRegion: (v: string) => DatalakeNode<Id>;
+  withVersioningEnabled: (v: boolean) => DatalakeNode<Id>;
+  withRetentionDays: (v: number) => DatalakeNode<Id>;
+};
+declare const Datalake: <const Id extends string>(cfg: {
+  id: Id;
+}) => DatalakeNode<Id>;
+type DistributedDataProcessingNode<Id extends string = string> = ComponentNode<Id, 'BigData.DistributedDataProcessing'> & {
+  withWorkspaceName: (v: string) => DistributedDataProcessingNode<Id>;
+};
+declare const DistributedDataProcessing: <const Id extends string>(cfg: {
+  id: Id;
+}) => DistributedDataProcessingNode<Id>;
+//#endregion
+//#region src/model/components/messaging.d.ts
+type BrokerNode<Id extends string = string> = ComponentNode<Id, 'Messaging.Broker'> & {
+  withTier: (v: string) => BrokerNode<Id>;
+  withRegion: (v: string) => BrokerNode<Id>;
+  withEncryption: (v: 'at-rest' | 'none') => BrokerNode<Id>;
+};
+declare const Broker: <const Id extends string>(cfg: {
+  id: Id;
+}) => BrokerNode<Id>;
+type MessagingEntityNode<Id extends string = string> = ComponentNode<Id, 'Messaging.MessagingEntity'> & {
+  withMessageRetentionHours: (v: number) => MessagingEntityNode<Id>;
+  withPartitionCount: (v: number) => MessagingEntityNode<Id>;
+  withDeadLetterEnabled: (v: boolean) => MessagingEntityNode<Id>;
+  withMaxDeliveryAttempts: (v: number) => MessagingEntityNode<Id>;
+  dependsOn: (other: AnyNode) => MessagingEntityNode<Id>;
+};
+declare const MessagingEntity: <const Id extends string>(cfg: {
+  id: Id;
+}) => MessagingEntityNode<Id>;
+//#endregion
+//#region src/model/components/api_management.d.ts
+type Route = {
+  path: string;
+  methods?: string[];
+  upstream?: string;
+};
+type ApiGatewayNode<Id extends string = string> = ComponentNode<Id, 'APIManagement.ApiGateway'> & {
+  withHttpsOnly: (v: boolean) => ApiGatewayNode<Id>;
+  withCustomDomain: (v: string) => ApiGatewayNode<Id>;
+  withCors: (v: {
+    allowOrigins: string[];
+  }) => ApiGatewayNode<Id>;
+  withRateLimit: (v: {
+    requestsPerSecond: number;
+  }) => ApiGatewayNode<Id>;
+  withRoutes: (v: Route[]) => ApiGatewayNode<Id>;
+};
+declare const ApiGateway: <const Id extends string>(cfg: {
+  id: Id;
+}) => ApiGatewayNode<Id>;
+//#endregion
+//#region src/model/components/observability.d.ts
+type MonitoringNode<Id extends string = string> = ComponentNode<Id, 'Observability.Monitoring'> & {
+  withRetentionDays: (v: number) => MonitoringNode<Id>;
+  withScrapeInterval: (v: number) => MonitoringNode<Id>;
+};
+declare const Monitoring: <const Id extends string>(cfg: {
+  id: Id;
+}) => MonitoringNode<Id>;
+type TracingNode<Id extends string = string> = ComponentNode<Id, 'Observability.Tracing'> & {
+  withRetentionDays: (v: number) => TracingNode<Id>;
+  withSamplingRate: (v: number) => TracingNode<Id>;
+};
+declare const Tracing: <const Id extends string>(cfg: {
+  id: Id;
+}) => TracingNode<Id>;
+type LoggingNode<Id extends string = string> = ComponentNode<Id, 'Observability.Logging'> & {
+  withRetentionDays: (v: number) => LoggingNode<Id>;
+};
+declare const Logging: <const Id extends string>(cfg: {
+  id: Id;
+}) => LoggingNode<Id>;
+//#endregion
+//#region src/model/components/security.d.ts
+type ServiceMeshNode<Id extends string = string> = ComponentNode<Id, 'Security.ServiceMesh'> & {
+  withMtlsMode: (v: 'off' | 'permissive' | 'strict') => ServiceMeshNode<Id>;
+  withAuthenticationMode: (v: string) => ServiceMeshNode<Id>;
+  withTags: (v: Record<string, string>) => ServiceMeshNode<Id>;
+};
+declare const ServiceMesh: <const Id extends string>(cfg: {
+  id: Id;
+}) => ServiceMeshNode<Id>;
+type IdentityProviderNode<Id extends string = string> = ComponentNode<Id, 'Security.IdentityProvider'> & {
+  withUserDirectoryName: (v: string) => IdentityProviderNode<Id>;
+  withPasswordPolicy: (v: {
+    minLength: number;
+  }) => IdentityProviderNode<Id>;
+  withMfaConfiguration: (v: 'OFF' | 'OPTIONAL' | 'ON') => IdentityProviderNode<Id>;
+  withSessionDuration: (v: number) => IdentityProviderNode<Id>;
+  withTags: (v: Record<string, string>) => IdentityProviderNode<Id>;
+};
+declare const IdentityProvider: <const Id extends string>(cfg: {
+  id: Id;
+}) => IdentityProviderNode<Id>;
+//#endregion
+//#region src/model/components/custom_workloads.d.ts
+type WorkloadNode<Id extends string = string> = ComponentNode<Id, 'CustomWorkloads.Workload'> & {
+  withImage: (v: string) => WorkloadNode<Id>;
+  withPort: (v: number) => WorkloadNode<Id>;
+  withReplicas: (v: number) => WorkloadNode<Id>;
+  withEnv: (v: Record<string, string>) => WorkloadNode<Id>;
+  withCpuRequest: (v: string) => WorkloadNode<Id>;
+  withMemoryRequest: (v: string) => WorkloadNode<Id>;
+  withMaxReplicas: (v: number) => WorkloadNode<Id>;
+  withHealthCheck: (v: {
+    path: string;
+    port: number;
+  }) => WorkloadNode<Id>;
+};
+declare const Workload: <const Id extends string>(cfg: {
+  id: Id;
+}) => WorkloadNode<Id>;
+type FunctionNode<Id extends string = string> = ComponentNode<Id, 'CustomWorkloads.Function'> & {
+  withSourceArtifact: (v: string) => FunctionNode<Id>;
+  withRuntime: (v: string) => FunctionNode<Id>;
+  withEnvironment: (v: Record<string, string>) => FunctionNode<Id>;
+  withMemory: (v: number) => FunctionNode<Id>;
+  withTimeout: (v: number) => FunctionNode<Id>;
+  withConcurrency: (v: number) => FunctionNode<Id>;
+};
+declare const Function: <const Id extends string>(cfg: {
+  id: Id;
+}) => FunctionNode<Id>;
+//#endregion
+//#region src/model/offers/network_and_compute.d.ts
+declare const AwsVpc: (config: {}) => Offer<"NetworkAndCompute.VirtualNetwork", {}>;
+declare const AzureVnet: (config: {}) => Offer<"NetworkAndCompute.VirtualNetwork", {}>;
+declare const GcpVpc: (config: {}) => Offer<"NetworkAndCompute.VirtualNetwork", {}>;
+declare const AwsSubnet: (config: {}) => Offer<"NetworkAndCompute.Subnet", {}>;
+declare const AzureSubnet: (config: {}) => Offer<"NetworkAndCompute.Subnet", {}>;
+declare const GcpSubnet: (config: {}) => Offer<"NetworkAndCompute.Subnet", {}>;
+declare const AwsSecurityGroup: (config: {}) => Offer<"NetworkAndCompute.SecurityGroup", {}>;
+declare const AzureNsg: (config: {
+  location: string;
+  resourceGroup: string;
+}) => Offer<"NetworkAndCompute.SecurityGroup", {
+  location: string;
+  resourceGroup: string;
+}>;
+declare const GcpFirewall: (config: {}) => Offer<"NetworkAndCompute.SecurityGroup", {}>;
+declare const Ec2Instance: (config: {
+  amiId: string;
+  instanceType: string;
+}) => Offer<"NetworkAndCompute.VirtualMachine", {
+  amiId: string;
+  instanceType: string;
+}>;
+declare const AzureVm: (config: {
+  vmSize: string;
+}) => Offer<"NetworkAndCompute.VirtualMachine", {
+  vmSize: string;
+}>;
+declare const GcpVm: (config: {
+  machineType: string;
+}) => Offer<"NetworkAndCompute.VirtualMachine", {
+  machineType: string;
+}>;
+declare const VsphereVm: (config: {
+  template: string;
+}) => Offer<"NetworkAndCompute.VirtualMachine", {
+  template: string;
+}>;
+declare const OpenshiftVm: (config: {}) => Offer<"NetworkAndCompute.VirtualMachine", {}>;
+declare const Eks: (config: {}) => Offer<"NetworkAndCompute.ContainerPlatform", {}>;
+declare const Aks: (config: {}) => Offer<"NetworkAndCompute.ContainerPlatform", {}>;
+declare const Gke: (config: {}) => Offer<"NetworkAndCompute.ContainerPlatform", {}>;
+declare const AwsLb: (config: {}) => Offer<"NetworkAndCompute.LoadBalancer", {}>;
+declare const AzureLb: (config: {}) => Offer<"NetworkAndCompute.LoadBalancer", {}>;
+declare const GcpGlb: (config: {}) => Offer<"NetworkAndCompute.LoadBalancer", {}>;
+declare const OciVcn: (config: {}) => Offer<"NetworkAndCompute.VirtualNetwork", {}>;
+declare const OciSubnet: (config: {
+  availabilityDomain?: string;
+}) => Offer<"NetworkAndCompute.Subnet", {
+  availabilityDomain?: string;
+}>;
+declare const OciSecurityList: (config: {
+  compartmentId: string;
+}) => Offer<"NetworkAndCompute.SecurityGroup", {
+  compartmentId: string;
+}>;
+declare const OciInstance: (config: {
+  shape: string;
+}) => Offer<"NetworkAndCompute.VirtualMachine", {
+  shape: string;
+}>;
+declare const HetznerNetwork: (config: {}) => Offer<"NetworkAndCompute.VirtualNetwork", {}>;
+declare const HetznerSubnet: (config: {
+  networkZone?: string;
+}) => Offer<"NetworkAndCompute.Subnet", {
+  networkZone?: string;
+}>;
+declare const HetznerFirewall: (config: {}) => Offer<"NetworkAndCompute.SecurityGroup", {}>;
+declare const HetznerServer: (config: {
+  serverType: string;
+}) => Offer<"NetworkAndCompute.VirtualMachine", {
+  serverType: string;
+}>;
+declare const VspherePortGroup: (config: {
+  dvSwitchName?: string;
+}) => Offer<"NetworkAndCompute.VirtualNetwork", {
+  dvSwitchName?: string;
+}>;
+declare const VsphereVlan: (config: {
+  vlanId?: number;
+}) => Offer<"NetworkAndCompute.Subnet", {
+  vlanId?: number;
+}>;
+declare const OpenshiftSecurityGroup: (config: {
+  name?: string;
+}) => Offer<"NetworkAndCompute.SecurityGroup", {
+  name?: string;
+}>;
+declare const OpenshiftService: (config: {}) => Offer<"NetworkAndCompute.LoadBalancer", {}>;
+//#endregion
+//#region src/model/offers/storage.d.ts
+declare const AwsS3: (config: {
+  bucketRegion: string;
+}) => Offer<"Storage.ObjectStorage", {
+  bucketRegion: string;
+}>;
+declare const AzureBlob: (config: {
+  accountTier: string;
+}) => Offer<"Storage.ObjectStorage", {
+  accountTier: string;
+}>;
+declare const GcsBucket: (config: {
+  location: string;
+}) => Offer<"Storage.ObjectStorage", {
+  location: string;
+}>;
+declare const MinIO: (config: {
+  storageClass?: string;
+}) => Offer<"Storage.ObjectStorage", {
+  storageClass?: string;
+}>;
+declare const AzurePostgresDbms: (config: {
+  resourceGroup: string;
+}) => Offer<"Storage.RelationalDbms", {
+  resourceGroup: string;
+}>;
+declare const GcpPostgresDbms: (config: {
+  tier: string;
+}) => Offer<"Storage.RelationalDbms", {
+  tier: string;
+}>;
+declare const ArubaMySqlDbms: (config: {
+  region: string;
+}) => Offer<"Storage.RelationalDbms", {
+  region: string;
+}>;
+declare const AzurePostgresDatabase: (config: {}) => Offer<"Storage.RelationalDatabase", {}>;
+declare const GcpPostgresDatabase: (config: {}) => Offer<"Storage.RelationalDatabase", {}>;
+declare const OpenshiftPersistentVolume: (config: {
+  storageSize?: string;
+  storageClassName?: string;
+}) => Offer<"Storage.ObjectStorage", {
+  storageSize?: string;
+  storageClassName?: string;
+}>;
+//#endregion
+//#region src/model/offers/big_data.d.ts
+declare const AwsDatabricksCluster: (config: Record<string, never>) => Offer<"BigData.ComputeCluster", Record<string, never>>;
+declare const AzureDatabricksCluster: (config: Record<string, never>) => Offer<"BigData.ComputeCluster", Record<string, never>>;
+declare const GcpDatabricksCluster: (config: Record<string, never>) => Offer<"BigData.ComputeCluster", Record<string, never>>;
+declare const CaaSSparkCluster: (config: Record<string, never>) => Offer<"BigData.ComputeCluster", Record<string, never>>;
+declare const AwsDatabricksJob: (config: Record<string, never>) => Offer<"BigData.DataProcessingJob", Record<string, never>>;
+declare const AzureDatabricksJob: (config: Record<string, never>) => Offer<"BigData.DataProcessingJob", Record<string, never>>;
+declare const GcpDatabricksJob: (config: Record<string, never>) => Offer<"BigData.DataProcessingJob", Record<string, never>>;
+declare const CaaSSparkJob: (config: Record<string, never>) => Offer<"BigData.DataProcessingJob", Record<string, never>>;
+declare const AwsDatabricksMlflow: (config: Record<string, never>) => Offer<"BigData.MlExperiment", Record<string, never>>;
+declare const AzureDatabricksMlflow: (config: Record<string, never>) => Offer<"BigData.MlExperiment", Record<string, never>>;
+declare const GcpDatabricksMlflow: (config: Record<string, never>) => Offer<"BigData.MlExperiment", Record<string, never>>;
+declare const CaaSMlflow: (config: Record<string, never>) => Offer<"BigData.MlExperiment", Record<string, never>>;
+declare const AwsS3Datalake: (config: {
+  bucket: string;
+}) => Offer<"BigData.Datalake", {
+  bucket: string;
+}>;
+declare const AzureDatalake: (config: {
+  resourceGroup: string;
+}) => Offer<"BigData.Datalake", {
+  resourceGroup: string;
+}>;
+declare const GcpDatalake: (config: {
+  bucketName: string;
+}) => Offer<"BigData.Datalake", {
+  bucketName: string;
+}>;
+declare const AwsDatabricks: (config: {
+  pricingTier: string;
+}) => Offer<"BigData.DistributedDataProcessing", {
+  pricingTier: string;
+}>;
+declare const AzureDatabricks: (config: {
+  pricingTier: string;
+}) => Offer<"BigData.DistributedDataProcessing", {
+  pricingTier: string;
+}>;
+declare const GcpDatabricks: (config: {
+  pricingTier: string;
+}) => Offer<"BigData.DistributedDataProcessing", {
+  pricingTier: string;
+}>;
+//#endregion
+//#region src/model/offers/messaging.d.ts
+declare const AzureServiceBus: (config: {
+  resourceGroup: string;
+}) => Offer<"Messaging.Broker", {
+  resourceGroup: string;
+}>;
+declare const GcpPubSub: (config: Record<string, never>) => Offer<"Messaging.Broker", Record<string, never>>;
+/** Vendor-neutral self-hosted Kafka — no `provider`. */
+declare const Kafka: (config: {
+  namespace?: string;
+}) => Offer<"Messaging.Broker", {
+  namespace?: string;
+}>;
+declare const AzureServiceBusTopic: (config: Record<string, never>) => Offer<"Messaging.MessagingEntity", Record<string, never>>;
+declare const GcpPubSubTopic: (config: Record<string, never>) => Offer<"Messaging.MessagingEntity", Record<string, never>>;
+/** Vendor-neutral self-hosted Kafka topic — no `provider`. */
+declare const KafkaTopic: (config: Record<string, never>) => Offer<"Messaging.MessagingEntity", Record<string, never>>;
+//#endregion
+//#region src/model/offers/api_management.d.ts
+declare const AwsCloudFront: (config: {
+  region: string;
+}) => Offer<"APIManagement.ApiGateway", {
+  region: string;
+}>;
+declare const AzureApiManagement: (config: {
+  publisherEmail: string;
+  sku: string;
+}) => Offer<"APIManagement.ApiGateway", {
+  publisherEmail: string;
+  sku: string;
+}>;
+declare const GcpApiGateway: (config: {}) => Offer<"APIManagement.ApiGateway", {}>;
+declare const Ambassador: (config: {
+  namespace?: string;
+}) => Offer<"APIManagement.ApiGateway", {
+  namespace?: string;
+}>;
+declare const Traefik: (config: {
+  namespace?: string;
+}) => Offer<"APIManagement.ApiGateway", {
+  namespace?: string;
+}>;
+//#endregion
+//#region src/model/offers/observability.d.ts
+declare const Prometheus: (config: {
+  namespace?: string;
+}) => Offer<"Observability.Monitoring", {
+  namespace?: string;
+}>;
+declare const Jaeger: (config: {
+  namespace?: string;
+}) => Offer<"Observability.Tracing", {
+  namespace?: string;
+}>;
+declare const ObservabilityElastic: (config: {
+  namespace?: string;
+  elasticVersion?: string;
+}) => Offer<"Observability.Logging", {
+  namespace?: string;
+  elasticVersion?: string;
+}>;
+//#endregion
+//#region src/model/offers/security.d.ts
+declare const Ocelot: (config: {
+  namespace?: string;
+}) => Offer<"Security.ServiceMesh", {
+  namespace?: string;
+}>;
+declare const Cognito: (config: {}) => Offer<"Security.IdentityProvider", {}>;
+declare const Keycloak: (config: {
+  namespace?: string;
+}) => Offer<"Security.IdentityProvider", {
+  namespace?: string;
+}>;
+//#endregion
+//#region src/model/offers/custom_workloads.d.ts
+declare const EcsService: (config: {
+  launchType: string;
+}) => Offer<"CustomWorkloads.Workload", {
+  launchType: string;
+}>;
+declare const CloudRun: (config: {
+  region: string;
+}) => Offer<"CustomWorkloads.Workload", {
+  region: string;
+}>;
+declare const AzureContainerApp: (config: {
+  resourceGroup: string;
+}) => Offer<"CustomWorkloads.Workload", {
+  resourceGroup: string;
+}>;
+declare const OpenshiftWorkload: (config: {
+  namespace?: string;
+}) => Offer<"CustomWorkloads.Workload", {
+  namespace?: string;
+}>;
+declare const K8sWorkload: (config: {
+  namespace?: string;
+}) => Offer<"CustomWorkloads.Workload", {
+  namespace?: string;
+}>;
+declare const AwsLambda: (config: {
+  roleArn: string;
+  handler: string;
+}) => Offer<"CustomWorkloads.Function", {
+  roleArn: string;
+  handler: string;
+}>;
+declare const AzureFunction: (config: Record<string, never>) => Offer<"CustomWorkloads.Function", Record<string, never>>;
+declare const GcpFunction: (config: {
+  entryPoint: string;
+}) => Offer<"CustomWorkloads.Function", {
+  entryPoint: string;
+}>;
+//#endregion
+export { Aks, Ambassador, AnyNode, ApiGateway, ApiGatewayNode, ArubaMySqlDbms, AwsCloudFront, AwsDatabricks, AwsDatabricksCluster, AwsDatabricksJob, AwsDatabricksMlflow, AwsLambda, AwsLb, AwsS3, AwsS3Datalake, AwsSecurityGroup, AwsSubnet, AwsVpc, AzureApiManagement, AzureBlob, AzureContainerApp, AzureDatabricks, AzureDatabricksCluster, AzureDatabricksJob, AzureDatabricksMlflow, AzureDatalake, AzureFunction, AzureLb, AzureNsg, AzurePostgresDatabase, AzurePostgresDbms, AzureServiceBus, AzureServiceBusTopic, AzureSubnet, AzureVm, AzureVnet, Blueprint, Broker, BrokerNode, CaaSMlflow, CaaSSparkCluster, CaaSSparkJob, ChildContext, CloudRun, Cognito, ComponentLink, ComponentNode, ComputeCluster, ComputeClusterNode, ContainerPlatform, ContainerPlatformNode, Credentials, DataProcessingJob, DataProcessingJobNode, Datalake, DatalakeNode, DeliveryModel, DeployOptions, DistributedDataProcessing, DistributedDataProcessingNode, Ec2Instance, EcsService, Eks, Fractal, Function, FunctionNode, GcpApiGateway, GcpDatabricks, GcpDatabricksCluster, GcpDatabricksJob, GcpDatabricksMlflow, GcpDatalake, GcpFirewall, GcpFunction, GcpGlb, GcpPostgresDatabase, GcpPostgresDbms, GcpPubSub, GcpPubSubTopic, GcpSubnet, GcpVm, GcpVpc, GcsBucket, Gke, HetznerFirewall, HetznerNetwork, HetznerServer, HetznerSubnet, IdentityProvider, IdentityProviderNode, InstantiationContext, Jaeger, K8sWorkload, Kafka, KafkaTopic, Keycloak, LiveSystem, LiveSystemComponent, LoadBalancer, LoadBalancerNode, Logging, LoggingNode, MessagingEntity, MessagingEntityNode, MinIO, MlExperiment, MlExperimentNode, Monitoring, MonitoringNode, NodePool, NodeState, ObjectStorage, ObjectStorageNode, ObservabilityElastic, Ocelot, OciInstance, OciSecurityList, OciSubnet, OciVcn, Offer, OpenshiftPersistentVolume, OpenshiftSecurityGroup, OpenshiftService, OpenshiftVm, OpenshiftWorkload, OwnerRef, Prometheus, Provider, RelationalDatabase, RelationalDatabaseNode, RelationalDbms, RelationalDbmsNode, Route, Rule, SecurityGroup, SecurityGroupNode, Selection, SerializedComponent, ServiceMesh, ServiceMeshNode, SlotOps, Subnet, SubnetNode, ToLiveSystemArgs, Tracing, TracingNode, Traefik, TypedToLiveSystemArgs, Version, VirtualMachine, VirtualMachineNode, VirtualNetwork, VirtualNetworkNode, VspherePortGroup, VsphereVlan, VsphereVm, Workload, WorkloadNode, addDependency, createFractal, defineOffer, deploy, destroy, guardrail, newNode };