@veltrixsecops/app-sdk 3.2.0 → 3.5.0

package/dist/byol/index.d.ts

@@ -0,0 +1,578 @@
+import React__default from 'react';
+import { BadgeVariant } from '../ui/index.js';
+
+/** A region association satellite row (indexer / search-head placement). */
+interface ByolRegion {
+    id: string;
+    region: string;
+}
+/**
+ * Control-plane consolidation layout. Trades HA/isolation for cost by combining
+ * management roles onto fewer instances:
+ *  - `dedicated`   — 5 instances, one role each (LM, CM, SH-deployer, DS, MC).
+ *  - `consolidated`— ~3 instances; CM and SH-deployer stay isolated, the rest combine.
+ *  - `single`      — 1 manager node running every management role (small / non-HA).
+ * Applies to distributed deployments; single-instance deployments ignore it.
+ */
+type ControlPlaneLayout = 'dedicated' | 'consolidated' | 'single';
+/** How a cluster's sites are addressed: availability zones (same region) or regions. */
+type PlacementGranularity = 'az' | 'region';
+/** One placement target with its share of the cluster's nodes. */
+interface PlacementSite {
+    /** AZ id (e.g. `us-east-1a`) when granularity is `az`, or a region code (e.g. `us-west-2`) when `region`. */
+    site: string;
+    /** Percent of the cluster's nodes placed on this site. Percents across a cluster's sites sum to 100. */
+    percent: number;
+}
+/**
+ * Placement of a single cluster tier. `single` keeps every node in the standard
+ * main region/zone; `multi-site` spreads nodes across `sites` by percent.
+ * ONLY the indexer and search-head tiers accept multi-site placement — every
+ * other tier is always single-site in the main region.
+ */
+interface ClusterPlacement {
+    mode: 'single' | 'multi-site';
+    granularity?: PlacementGranularity;
+    sites?: PlacementSite[];
+}
+/** Default single-site placement (all nodes in the main region). */
+declare const SINGLE_SITE_PLACEMENT: ClusterPlacement;
+/** Minimum heavy forwarders in a distributed ingest tier. */
+declare const MIN_HEAVY_FORWARDERS = 1;
+interface ByolInfrastructure {
+    id: string;
+    name: string;
+    deploymentType?: string;
+    environmentType?: string;
+    indexerCount?: number;
+    searchHeadCount?: number;
+    status?: string;
+    hosting_type?: string;
+    cloudProviderId?: string | null;
+    region?: string | null;
+    indexerRegions?: ByolRegion[];
+    searchHeadRegions?: ByolRegion[];
+    /** Deployment target: platform-hosted network, or a customer-owned VPC. Defaults to 'shared'. */
+    networkMode?: 'shared' | 'dedicated' | 'existing' | string;
+    /** DNS strategy for the deployment. Defaults to 'managed'. */
+    dnsMode?: 'managed' | 'delegated' | 'private-only' | string;
+    /** Platform cloud account connection backing a BYOC (dedicated/existing) deployment. */
+    cloudAccountConnectionId?: string | null;
+    /** Control-plane consolidation layout (distributed only). Defaults to 'dedicated'. */
+    controlPlaneLayout?: ControlPlaneLayout;
+    /** Heavy forwarder count in the ingest tier (distributed only). Defaults to 1. */
+    heavyForwarderCount?: number;
+    /** Compute size override for every node (e.g. AWS `t2.medium`); empty = cloud default. */
+    instanceType?: string | null;
+    /** Placement of the indexer cluster — single-site or multi-site by percent. */
+    indexerPlacement?: ClusterPlacement;
+    /** Placement of the search-head cluster — single-site or multi-site by percent. */
+    searchHeadPlacement?: ClusterPlacement;
+    /** Selected software version (app catalog entry id) to install on every node. */
+    versionId?: string;
+    updatedAt?: string;
+    createdAt?: string;
+}
+/** A persisted resource row (from GET /byol/:id/resources). */
+interface ByolResource {
+    id: string;
+    infrastructureId: string;
+    tier: string;
+    kind: string;
+    name: string;
+    role: string | null;
+    region: string | null;
+    /** Availability zone within `region` for a multi-AZ-placed node; null otherwise. */
+    zone?: string | null;
+    /** Management roles a consolidated control-plane instance runs; null otherwise. */
+    roles?: string[] | null;
+    status: string;
+    externalRef: string | null;
+    message: string | null;
+    planKey: string;
+    sortOrder: number;
+}
+/** A deployment step (from GET /byol/:id/deployments → steps). */
+interface ByolDeploymentStep {
+    id: string;
+    deploymentId: string;
+    stepOrder: number;
+    key: string;
+    title: string;
+    status: string;
+    detail: string | null;
+    logs: string | null;
+    startedAt: string | null;
+    completedAt: string | null;
+}
+/** A deployment run (from GET /byol/:id/deployments). */
+interface ByolDeployment {
+    id: string;
+    infrastructureId: string;
+    action: string;
+    status: string;
+    message: string | null;
+    startedAt: string;
+    completedAt: string | null;
+    steps: ByolDeploymentStep[];
+}
+/** Platform tag — the customer's environment tags feed the Environment picker. */
+interface Tag {
+    id: string;
+    name: string;
+}
+/** Platform cloud provider — feeds the "Provider" picker (plus Self-Hosted). */
+interface CloudProvider {
+    id: string;
+    name: string;
+    code?: string;
+    isActive?: boolean;
+}
+interface CloudRegion {
+    id: string;
+    name: string;
+    code: string;
+    isActive?: boolean;
+}
+/**
+ * Platform cloud account connection — feeds the "Cloud account" picker shown
+ * for BYOC (dedicated/existing network) deployment targets. Sourced from
+ * `GET /api/cloud-accounts`. Only `VERIFIED` accounts matching the selected
+ * cloud provider are offered.
+ */
+interface CloudAccount {
+    id: string;
+    provider: 'aws' | 'azure' | 'gcp' | 'hetzner' | string;
+    name: string;
+    status: 'UNVERIFIED' | 'VERIFIED' | 'ERROR' | string;
+    authMethod?: string;
+    /**
+     * 'customer' — the tenant's own account (BYOC / dedicated / existing).
+     * 'platform' — a Veltrix-managed account a hosted (shared) deployment provisions
+     * through. The form offers platform accounts for hosted, customer accounts for BYOC.
+     */
+    scope?: 'customer' | 'platform' | string;
+}
+interface FormState {
+    name: string;
+    deploymentType: string;
+    environmentType: string;
+    /** A cloud provider id, or the SELF_HOSTED sentinel. */
+    providerId: string;
+    region: string;
+    indexerCount: string;
+    searchHeadCount: string;
+    /** Deployment target: 'shared' (Veltrix-hosted), 'dedicated', or 'existing' (BYOC). */
+    networkMode: string;
+    /** DNS strategy: 'managed', 'delegated', or 'private-only'. */
+    dnsMode: string;
+    /** Platform cloud account connection id, required when networkMode is BYOC. */
+    cloudAccountConnectionId: string;
+    /** Control-plane consolidation layout (distributed only). */
+    controlPlaneLayout: ControlPlaneLayout;
+    /** Heavy forwarder count as a form string (distributed only, min 1). */
+    heavyForwarderCount: string;
+    /** Compute size override for every node; empty = cloud default (t2.medium-class). */
+    instanceType: string;
+    /** Placement of the indexer cluster. */
+    indexerPlacement: ClusterPlacement;
+    /** Placement of the search-head cluster. */
+    searchHeadPlacement: ClusterPlacement;
+    /** Selected software version (app catalog entry id); empty = app-default. */
+    versionId: string;
+}
+/**
+ * A link surfaced in the detail view's Configuration section. The app supplies
+ * these (the SDK stays app-agnostic). When `configTypeId` + `configBase` are
+ * present the link resolves to `<configBase>/<configTypeId>`; otherwise `href`
+ * is used verbatim.
+ */
+interface ByolConfigLink {
+    key: string;
+    title: string;
+    description: string;
+    configTypeId?: string;
+    href?: string;
+}
+interface ByolInfrastructureManagerProps {
+    /** Base URL of the app's BYOL routes, e.g. `/api/apps/splunk-enterprise/byol`. */
+    apiBase: string;
+    /** Card title. Defaults to "BYOL Infrastructure". */
+    title?: string;
+    /** Deployment topology options. Defaults to Single instance + Distributed. */
+    deploymentTypes?: Array<{
+        value: string;
+        label: string;
+    }>;
+    /**
+     * Optional base path to this app's configuration canvases, e.g.
+     * `/apps/splunk-enterprise/config`. Combined with each link's `configTypeId`
+     * to deep-link the detail view's Configuration section.
+     */
+    configBase?: string;
+    /** Configuration links to surface in the detail view (app-supplied). */
+    configLinks?: ByolConfigLink[];
+    /**
+     * Software version options for the "Splunk version" form picker (app-supplied —
+     * the SDK has no notion of Splunk). Omit or pass an empty array to hide the
+     * picker entirely (e.g. an app with no version catalog).
+     */
+    versionOptions?: Array<{
+        value: string;
+        label: string;
+    }>;
+    /**
+     * Version id a NEW infrastructure's form should default to (typically the
+     * catalog's "latest" entry). Ignored when `versionOptions` is empty. Existing
+     * rows always reflect their own stored `versionId`, never this default.
+     */
+    defaultVersionId?: string;
+}
+/** Control-plane consolidation options for the "Control plane" form section. */
+declare const CONTROL_PLANE_LAYOUT_OPTIONS: Array<{
+    value: ControlPlaneLayout;
+    label: string;
+    description: string;
+}>;
+/** Placement granularity options for a cluster's "Placement" form section. */
+declare const PLACEMENT_GRANULARITY_OPTIONS: Array<{
+    value: PlacementGranularity;
+    label: string;
+}>;
+
+/**
+ * Reusable BYOL infrastructure manager: a searchable/filterable list whose rows
+ * open a full deployment console (the detail view), a Provider picker (platform
+ * cloud providers plus Self-Hosted), an Environment picker fed by the customer's
+ * tags, and a cloud region picker shown only for a distributed cloud deployment.
+ * The app owns the data (its own DB table + routes); this component owns the UI.
+ */
+declare const ByolInfrastructureManager: React__default.FC<ByolInfrastructureManagerProps>;
+
+interface ByolInfrastructureDetailProps {
+    apiBase: string;
+    /** The row the user clicked — rendered instantly, then refreshed from the API. */
+    initialInfra: ByolInfrastructure;
+    configBase?: string;
+    configLinks?: ByolConfigLink[];
+    onBack: () => void;
+    onEdit: (infra: ByolInfrastructure) => void;
+    onDeleted: () => void;
+    /** Called after any mutation so the parent list can refresh statuses. */
+    onChanged: () => void;
+    /** Bumped by the parent (e.g. after an edit via the shared form) to force a reload. */
+    reloadSignal?: number;
+}
+declare const ByolInfrastructureDetail: React__default.FC<ByolInfrastructureDetailProps>;
+
+/** Context a BYOL tag set is derived from — everything the app already holds. */
+interface ByolTagInput {
+    /** Tenant id — cost attribution + tenant isolation. */
+    customerId: string;
+    /**
+     * Human-readable, unique tenant shortname (set in Settings → Organization).
+     * Used as the `Veltrix:Customer` value so cloud tags are legible; falls back
+     * to `customerId` when the tenant has not set one.
+     */
+    customerShortName?: string | null;
+    /** Unique environment id (the infrastructure record id). */
+    infrastructureId: string;
+    /** Human environment name. */
+    name: string;
+    /** Environment class, e.g. prod / staging / dev. */
+    environmentType: string;
+    /** Owning app, e.g. `splunk-enterprise`. */
+    appId: string;
+    /** Billing account / cost center; falls back to `customerId`. */
+    costCenter?: string | null;
+    /** Initiating user / owner; falls back to `customerId`. */
+    owner?: string | null;
+}
+/** An ordered tag map. Insertion order IS the canonical display order. */
+type ByolTags = Record<string, string>;
+/**
+ * The canonical tag keys, in the order they are emitted. Exported so callers +
+ * tests can assert against the contract without re-deriving it.
+ */
+declare const BYOL_TAG_KEYS: readonly ["Veltrix:Customer", "Veltrix:Environment", "Veltrix:EnvName", "Veltrix:EnvType", "Veltrix:App", "Veltrix:ManagedBy", "CostCenter", "Owner"];
+/** The constant value stamped on `Veltrix:ManagedBy` (drives tag-scoped IAM). */
+declare const MANAGED_BY = "Veltrix";
+/**
+ * Build the canonical cost-allocation / tenant-isolation tag set for a BYOL
+ * environment. Pure: the same input always yields the same ordered map.
+ *
+ *   Veltrix:Customer    = customerShortName ?? customerId
+ *   Veltrix:Environment = infrastructureId      (unique env id)
+ *   Veltrix:EnvName     = name
+ *   Veltrix:EnvType     = environmentType       (prod / staging / …)
+ *   Veltrix:App         = appId                 (splunk-enterprise, …)
+ *   Veltrix:ManagedBy   = Veltrix               (constant; tag-scoped IAM)
+ *   CostCenter          = costCenter ?? the customer label
+ *   Owner               = owner ?? the customer label
+ */
+declare function buildByolTags(input: ByolTagInput): ByolTags;
+
+/** A single resource's disposition in a plan. */
+type PlanAction = 'add' | 'change' | 'destroy' | 'noop';
+/** The minimal shape of a CURRENT persisted resource row diffPlan compares. */
+interface PlanDiffCurrent {
+    planKey: string;
+    tier: string;
+    kind: string;
+    name: string;
+    role: string | null;
+    region: string | null;
+    /** A `failed`/`attention` row is always re-planned as a change. */
+    status?: string;
+}
+/** The minimal shape of a DESIRED topology plan item diffPlan compares. */
+interface PlanDiffDesired {
+    planKey: string;
+    tier: string;
+    kind: string;
+    name: string;
+    role: string | null;
+    region: string | null;
+    sortOrder?: number;
+}
+/** The four buckets of a diff, keyed by `planKey`. add/change/noop hold the
+ *  desired item (the target state); destroy holds the current row being removed. */
+interface PlanDiff {
+    add: PlanDiffDesired[];
+    change: PlanDiffDesired[];
+    destroy: PlanDiffCurrent[];
+    noop: PlanDiffDesired[];
+}
+/** Count of each action — the header summary of the Plan modal. */
+interface ByolPlanSummary {
+    add: number;
+    change: number;
+    destroy: number;
+    noop: number;
+}
+/** One resource line in the plan, tagged with its action for the modal. */
+interface ByolPlanItem {
+    planKey: string;
+    action: PlanAction;
+    name: string;
+    role: string | null;
+    region: string | null;
+    kind: string;
+}
+/** Plan lines grouped by tier, in provisioning order. */
+interface ByolPlanGroup {
+    tier: string;
+    items: ByolPlanItem[];
+}
+/** The subnet the platform network allocator previewed / reserved for a stack. */
+interface ByolPlanNetwork {
+    /** Opaque handle to the shared per-(provider,region) Network (VPC/VNet/…). */
+    networkRef: string;
+    /** The /24 subnet CIDR carved for this stack, e.g. `10.20.4.0/24`. */
+    subnetCidr: string;
+}
+/**
+ * The full `GET /byol/:id/plan` response contract.
+ *
+ * The core diff (`summary` + `groups`) is computed by `buildByolPlan`; the app
+ * server ENRICHES the response with `network` (a dry-run subnet peek) + `tags`
+ * (the canonical tenant/cost tag set). Both are optional so the modal degrades
+ * gracefully: `networkUnavailable` flags that the allocator was unreachable, and
+ * `network` is simply absent for a self-hosted stack where it does not apply.
+ */
+interface ByolPlan {
+    summary: ByolPlanSummary;
+    groups: ByolPlanGroup[];
+    /** Subnet the allocator would carve for this stack (peek), when applicable. */
+    network?: ByolPlanNetwork;
+    /** Canonical tenant / cost-allocation tags every resource will carry. */
+    tags?: ByolTags;
+    /** Soft flag: the network allocator was unreachable, so `network` is absent. */
+    networkUnavailable?: boolean;
+}
+/**
+ * Diff the desired topology plan against the current persisted rows.
+ *
+ *  • add     — desired keys with no current row
+ *  • change  — desired keys whose current row differs (tier/kind/name/role/
+ *              region) or is failed/attention
+ *  • destroy — current rows whose key is no longer desired
+ *  • noop    — desired keys whose current row already matches
+ *
+ * Pure and non-mutating: it never touches its inputs.
+ */
+declare function diffPlan(current: PlanDiffCurrent[], desired: PlanDiffDesired[]): PlanDiff;
+/**
+ * Compute the full plan response from current + desired: the action counts plus
+ * every resource line grouped by tier in provisioning order. Destroyed rows are
+ * appended within their tier (they retain their tier but not a desired order).
+ */
+declare function buildByolPlan(current: PlanDiffCurrent[], desired: PlanDiffDesired[]): ByolPlan;
+/** Whether a plan has any actionable change (drives the modal's Apply gate). */
+declare function planHasChanges(summary: ByolPlanSummary): boolean;
+
+interface ByolPlanModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    /** The computed plan, or null while it is still loading. */
+    plan: ByolPlan | null;
+    /** True while the plan is being fetched. */
+    loading?: boolean;
+    /** A plan-fetch or apply error to surface inline. */
+    error?: string | null;
+    /** True while Apply is in flight. */
+    applying?: boolean;
+    /** Invoked by the primary Apply button. */
+    onApply: () => void;
+    /** Optional environment name, shown in the subtitle. */
+    infraName?: string;
+    /**
+     * Allow Apply even when the plan has no add/change/destroy — for a redeployable
+     * environment (a failed or never-deployed infra) where the user is RE-running
+     * the same plan rather than making a change.
+     */
+    allowApplyWithoutChanges?: boolean;
+}
+/**
+ * The Plan modal. Fetch the plan into `plan` (showing `loading` first), then let
+ * the user Apply. Apply is disabled while loading, while applying, and when the
+ * plan has no add/change/destroy.
+ */
+declare const ByolPlanModal: React__default.FC<ByolPlanModalProps>;
+
+interface DestroyPlanModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    /** The current persisted resources this destroy will tear down; null while (re)loading. */
+    resources: ByolResource[] | null;
+    /** True while the resource inventory is being (re)loaded. */
+    loading?: boolean;
+    /** A destroy-action error (from the `/destroy` call itself) to surface inline. */
+    error?: string | null;
+    /** True while the destroy request is in flight. */
+    destroying?: boolean;
+    /** Invoked by the primary (danger) Destroy button. */
+    onConfirm: () => void;
+    /** Optional environment name, shown in the subtitle. */
+    infraName?: string;
+}
+/**
+ * The Destroy modal. Shows every resource in `resources` as a destroy line
+ * grouped by tier. Destroy stays enabled even when the inventory hasn't
+ * loaded or is empty — the underlying `/destroy` action doesn't depend on this
+ * preview, so an unavailable/empty list must never block the user from tearing
+ * an environment down, only inform them the resource list itself was unavailable.
+ */
+declare const DestroyPlanModal: React__default.FC<DestroyPlanModalProps>;
+
+interface SiteAllocation {
+    site: string;
+    count: number;
+    /** The requested percent for this site (echoed for display / audit). */
+    percent: number;
+}
+/**
+ * Allocate `totalNodes` across a cluster's sites by percent.
+ *
+ * Rules:
+ *  - Every listed site receives at least one node (a site in the plan must be real).
+ *  - The remaining nodes are distributed by percent using the largest-remainder
+ *    method, so the counts sum to exactly `totalNodes`.
+ *  - Deterministic: ties in the remainder are broken by site order (no RNG).
+ *
+ * Callers must ensure `sites.length <= totalNodes` (see {@link validatePlacement});
+ * when that does not hold this still returns one node per site until it runs out,
+ * so it never returns a negative count.
+ */
+declare function allocateNodesBySite(totalNodes: number, sites: PlacementSite[]): SiteAllocation[];
+/**
+ * Validate a cluster placement against a node count. Returns a human-readable
+ * error string, or `null` when the placement is deployable.
+ */
+declare function validatePlacement(placement: ClusterPlacement | undefined, totalNodes: number): string | null;
+/**
+ * Resolve the placement actually used for a tier: multi-site placement is only
+ * honored for eligible (indexer / search-head) tiers; everything else collapses
+ * to single-site so callers can treat the result uniformly.
+ */
+declare function effectivePlacement(placement: ClusterPlacement | undefined, eligible: boolean): ClusterPlacement;
+
+/** Badge variant for an infrastructure status (falls back to neutral). */
+declare function statusVariant(status?: string): BadgeVariant;
+/** Human label for an infrastructure status (Title-Cases anything unknown). */
+declare function statusLabel(status?: string): string;
+/** Whether the environment is actively running (running/active). */
+declare function isRunning(status?: string): boolean;
+/** Whether a deploy has never been requested yet. */
+declare function isNotStarted(status?: string): boolean;
+declare function resourceStatusVariant(status?: string): BadgeVariant;
+declare function resourceStatusLabel(status?: string): string;
+declare function stepStatusVariant(status?: string): BadgeVariant;
+
+/** Coarse grouping used to lay the plan out by tier in the UI and DB. */
+type ByolResourceTier = 'foundation' | 'control-plane' | 'data' | 'search' | 'ingest';
+/** A stable machine kind for a resource, used for icons + worker correlation. */
+type ByolResourceKind = 'network' | 'load-balancer' | 'dns' | 'tls' | 'storage' | 'secrets' | 'license-file' | 'license-manager' | 'cluster-manager' | 'sh-deployer' | 'deployment-server' | 'monitoring-console' | 'indexer' | 'search-head' | 'hec' | 'heavy-forwarder' | 'standalone' | 'management-node';
+/** One resource in the plan. `planKey` is a stable identity for idempotent seeding. */
+interface ByolResourcePlanItem {
+    planKey: string;
+    tier: ByolResourceTier;
+    kind: ByolResourceKind;
+    name: string;
+    role: string;
+    region: string | null;
+    /** Availability zone within `region` (multi-AZ placement); null otherwise. */
+    zone?: string | null;
+    /** Machine-readable roles this instance runs — drives control-plane bring-up. */
+    roles?: string[];
+}
+interface ByolTopologyInput {
+    deploymentType?: string;
+    indexerCount?: number;
+    searchHeadCount?: number;
+    /** Display provider name, e.g. "AWS" or "Self-Hosted". */
+    hostingType?: string;
+    /** Whether the deployment targets a cloud provider (vs Self-Hosted). */
+    isCloud?: boolean;
+    /** Primary region + any per-node regions, in preference order. */
+    region?: string | null;
+    indexerRegions?: string[];
+    searchHeadRegions?: string[];
+    /** Control-plane consolidation layout (distributed only). Defaults to 'dedicated'. */
+    controlPlaneLayout?: ControlPlaneLayout;
+    /** Heavy forwarder count (distributed only). Defaults to 1. */
+    heavyForwarderCount?: number;
+    /** Multi-site placement of the indexer cluster (indexer/search tiers only). */
+    indexerPlacement?: ClusterPlacement | null;
+    /** Multi-site placement of the search-head cluster. */
+    searchHeadPlacement?: ClusterPlacement | null;
+}
+declare const TIER_LABELS: Record<ByolResourceTier, string>;
+/** Provisioning order the tiers deploy in (also the display order). */
+declare const TIER_ORDER: ByolResourceTier[];
+/**
+ * Build the ordered resource plan for a BYOL infrastructure.
+ *
+ * A single-instance deployment collapses to an all-in-one Splunk node plus the
+ * foundation. A distributed deployment expands to the full topology: control
+ * plane (license/cluster managers, deployment server, monitoring console, SH
+ * deployer), an N-peer indexer cluster, an M-member search-head cluster, and the
+ * ingest path (HEC + heavy forwarders).
+ */
+declare function buildByolResourcePlan(input: ByolTopologyInput): ByolResourcePlanItemWithOrder[];
+/** Attach the plan's stable sort order (kept separate so callers can persist it). */
+declare function stampOrder(item: ByolResourcePlanItem, index: number): ByolResourcePlanItem & {
+    sortOrder: number;
+};
+type ByolResourcePlanItemWithOrder = ReturnType<typeof stampOrder>;
+/**
+ * The ordered high-level steps a deployment run advances through. Mirrors the
+ * tier order plus the post-deploy phases. Workers report progress against these.
+ */
+declare const DEPLOYMENT_STEPS: Array<{
+    key: string;
+    title: string;
+    detail: string;
+}>;
+
+export { BYOL_TAG_KEYS, type ByolConfigLink, type ByolDeployment, type ByolDeploymentStep, type ByolInfrastructure, ByolInfrastructureDetail, ByolInfrastructureManager, type ByolInfrastructureManagerProps, type ByolPlan, type ByolPlanGroup, type ByolPlanItem, ByolPlanModal, type ByolPlanModalProps, type ByolPlanNetwork, type ByolPlanSummary, type ByolRegion, type ByolResource, type ByolResourceKind, type ByolResourcePlanItem, type ByolResourcePlanItemWithOrder, type ByolResourceTier, type ByolTagInput, type ByolTags, type ByolTopologyInput, CONTROL_PLANE_LAYOUT_OPTIONS, type CloudAccount, type CloudProvider, type CloudRegion, type ClusterPlacement, type ControlPlaneLayout, DEPLOYMENT_STEPS, DestroyPlanModal, type DestroyPlanModalProps, type FormState, MANAGED_BY, MIN_HEAVY_FORWARDERS, PLACEMENT_GRANULARITY_OPTIONS, type PlacementGranularity, type PlacementSite, type PlanAction, type PlanDiff, type PlanDiffCurrent, type PlanDiffDesired, SINGLE_SITE_PLACEMENT, type SiteAllocation, TIER_LABELS, TIER_ORDER, type Tag, allocateNodesBySite, buildByolPlan, buildByolResourcePlan, buildByolTags, ByolInfrastructureManager as default, diffPlan, effectivePlacement, isNotStarted, isRunning, planHasChanges, resourceStatusLabel, resourceStatusVariant, statusLabel, statusVariant, stepStatusVariant, validatePlacement };