@rulebricks/cli 1.9.0

package/dist/commands/upgrade.js

@@ -0,0 +1,239 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useCallback } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import SelectInput from "ink-select-input";
+import { BorderBox, Spinner, ThemeProvider, useTheme, Logo, } from "../components/common/index.js";
+import { loadDeploymentConfig, loadDeploymentState, updateDeploymentStatus, getHelmValuesPath, } from "../lib/config.js";
+import { upgradeChart, dryRunUpgrade } from "../lib/helm.js";
+import { formatDate, getAppVersionInfo, } from "../lib/versions.js";
+import { formatVersionDisplay, normalizeVersion } from "../lib/dockerHub.js";
+import { CHANGELOG_URL, getNamespace, getReleaseName, } from "../types/index.js";
+import { getDeployedImageVersions, rolloutRestart } from "../lib/kubernetes.js";
+import fs from "fs/promises";
+import YAML from "yaml";
+function UpgradeCommandInner({ name, targetVersion, dryRun, }) {
+    const { exit } = useApp();
+    const { colors } = useTheme();
+    const [step, setStep] = useState("loading");
+    const [config, setConfig] = useState(null);
+    const [versionInfo, setVersionInfo] = useState(null);
+    const [selectedVersion, setSelectedVersion] = useState(null);
+    const [error, setError] = useState(null);
+    const [dryRunOutput, setDryRunOutput] = useState(null);
+    // Store actual deployed HPS version separately (may differ from expected)
+    const [deployedHpsVersion, setDeployedHpsVersion] = useState(null);
+    useEffect(() => {
+        loadVersions();
+    }, []);
+    async function loadVersions() {
+        try {
+            const cfg = await loadDeploymentConfig(name);
+            setConfig(cfg);
+            const state = await loadDeploymentState(name);
+            // Get actual deployed versions from Kubernetes
+            const namespace = state?.application?.namespace || getNamespace(name);
+            const releaseName = getReleaseName(name);
+            const deployedVersions = await getDeployedImageVersions(releaseName, namespace);
+            // Use deployed version from K8s, fall back to state file if K8s query fails
+            const currentAppVersion = deployedVersions.appVersion || state?.application?.appVersion || null;
+            // Store actual deployed HPS version for display
+            setDeployedHpsVersion(deployedVersions.hpsVersion || state?.application?.hpsVersion || null);
+            const info = await getAppVersionInfo(cfg.licenseKey, currentAppVersion);
+            setVersionInfo(info);
+            if (targetVersion) {
+                // Find the version in available list
+                const targetVer = info.available.find((v) => v.version === targetVersion);
+                if (targetVer) {
+                    setSelectedVersion(targetVer);
+                    if (dryRun) {
+                        await performDryRun(targetVer);
+                    }
+                    else {
+                        setStep("confirm");
+                    }
+                }
+                else {
+                    setError(`Version ${targetVersion} not found`);
+                    setStep("error");
+                }
+            }
+            else {
+                setStep("select");
+            }
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : "Failed to load versions");
+            setStep("error");
+        }
+    }
+    async function performDryRun(version) {
+        try {
+            // Update helm values with new image tags before dry run
+            await updateHelmValuesWithVersion(version);
+            const state = await loadDeploymentState(name);
+            // Use namespace from state if available (backwards compat), otherwise compute from deployment name
+            const namespace = state?.application?.namespace || getNamespace(name);
+            const releaseName = getReleaseName(name);
+            const output = await dryRunUpgrade(name, { releaseName, namespace });
+            setDryRunOutput(output);
+            setStep("complete");
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : "Dry run failed");
+            setStep("error");
+        }
+    }
+    async function updateHelmValuesWithVersion(version) {
+        const valuesPath = getHelmValuesPath(name);
+        try {
+            const content = await fs.readFile(valuesPath, "utf8");
+            const values = YAML.parse(content);
+            // Update image tags
+            if (!values.rulebricks) {
+                values.rulebricks = {};
+            }
+            const rulebricks = values.rulebricks;
+            // Update app image tag
+            if (!rulebricks.app) {
+                rulebricks.app = {};
+            }
+            const app = rulebricks.app;
+            if (!app.image) {
+                app.image = {};
+            }
+            app.image.tag = version.version;
+            // Update HPS image tag
+            if (!rulebricks.hps) {
+                rulebricks.hps = {};
+            }
+            const hps = rulebricks.hps;
+            if (!hps.image) {
+                hps.image = {};
+            }
+            hps.image.tag =
+                version.hpsVersion || version.version;
+            // Save updated values
+            await fs.writeFile(valuesPath, YAML.stringify(values), "utf8");
+        }
+        catch (err) {
+            throw new Error(`Failed to update Helm values: ${err}`);
+        }
+    }
+    async function performUpgrade() {
+        if (!selectedVersion || !config)
+            return;
+        setStep("upgrading");
+        try {
+            // Update helm values with new image tags
+            await updateHelmValuesWithVersion(selectedVersion);
+            const state = await loadDeploymentState(name);
+            // Use namespace from state if available (backwards compat), otherwise compute from deployment name
+            const namespace = state?.application?.namespace || getNamespace(name);
+            const releaseName = getReleaseName(name);
+            // Perform the upgrade
+            await upgradeChart(name, { releaseName, namespace, wait: true });
+            // Force restart HPS statefulsets to ensure fresh images are pulled
+            // (pullPolicy: Always only pulls on pod restart, not on unchanged spec)
+            await rolloutRestart("statefulset", `${releaseName}-hps`, namespace);
+            await rolloutRestart("statefulset", `${releaseName}-hps-worker`, namespace);
+            // Update deployment state
+            await updateDeploymentStatus(name, "running", {
+                application: {
+                    appVersion: selectedVersion.version,
+                    hpsVersion: selectedVersion.hpsVersion || selectedVersion.version,
+                    namespace,
+                    url: `https://${config.domain}`,
+                },
+            });
+            setStep("complete");
+            setTimeout(() => exit(), 5000);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : "Upgrade failed");
+            setStep("error");
+        }
+    }
+    const handleVersionSelect = useCallback((item) => {
+        const version = versionInfo?.available.find((v) => v.version === item.value);
+        if (version) {
+            setSelectedVersion(version);
+            if (dryRun) {
+                performDryRun(version);
+            }
+            else {
+                setStep("confirm");
+            }
+        }
+    }, [versionInfo, dryRun]);
+    useInput((input, key) => {
+        if (step === "confirm") {
+            if (key.return) {
+                performUpgrade();
+            }
+            else if (key.escape) {
+                setStep("select");
+            }
+        }
+    });
+    if (step === "loading") {
+        return (_jsx(BorderBox, { title: "Version Manager", children: _jsx(Box, { marginY: 1, children: _jsx(Spinner, { label: "Loading version information..." }) }) }));
+    }
+    if (step === "error") {
+        return (_jsx(BorderBox, { title: "Upgrade Failed", children: _jsx(Box, { flexDirection: "column", marginY: 1, children: _jsxs(Text, { color: colors.error, children: ["\u2717 ", error] }) }) }));
+    }
+    if (step === "complete") {
+        if (dryRun && dryRunOutput) {
+            return (_jsx(BorderBox, { title: "Dry Run Results", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { color: colors.accent, children: "Preview of changes (no changes made):" }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.muted, children: [dryRunOutput.substring(0, 500), "..."] }) })] }) }));
+        }
+        return (_jsx(BorderBox, { title: "Upgrade Complete", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Text, { color: colors.success, bold: true, children: ["\u2713 Upgraded to ", formatVersionDisplay(selectedVersion?.version || "")] }), selectedVersion?.hpsVersion && (_jsxs(Text, { color: colors.muted, children: ["HPS version: ", formatVersionDisplay(selectedVersion.hpsVersion)] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["Run `rulebricks status ", name, "` to verify the deployment"] }) })] }) }));
+    }
+    if (step === "upgrading") {
+        return (_jsx(BorderBox, { title: "Upgrading", children: _jsx(Box, { marginY: 1, children: _jsx(Spinner, { label: `Installing ${formatVersionDisplay(selectedVersion?.version || "")}...` }) }) }));
+    }
+    if (step === "confirm") {
+        return (_jsx(BorderBox, { title: "Confirm Upgrade", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Text, { children: ["Current:", " ", _jsx(Text, { color: colors.accent, children: versionInfo?.current
+                                    ? formatVersionDisplay(versionInfo.current.version)
+                                    : "Not installed" }), deployedHpsVersion && (_jsxs(Text, { color: colors.muted, children: [" ", "(Solver: ", formatVersionDisplay(deployedHpsVersion), ")"] }))] }), _jsxs(Text, { children: ["Target:", " ", _jsx(Text, { color: colors.success, children: formatVersionDisplay(selectedVersion?.version || "") }), selectedVersion?.hpsVersion && (_jsxs(Text, { color: colors.muted, children: [" ", "(Solver: ", formatVersionDisplay(selectedVersion.hpsVersion), ")"] }))] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.warning, children: "\u26A0 This will upgrade your Rulebricks deployment." }), _jsx(Text, { color: colors.muted, children: "Pods will be restarted and there may be brief downtime." })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.success, bold: true, children: "Press Enter to continue, Esc to go back" }) })] }) }));
+    }
+    // Version selection screen
+    const versionItems = versionInfo?.available.map((v) => ({
+        label: formatVersionDisplay(v.version),
+        value: v.version,
+        hpsVersion: v.hpsVersion,
+        date: v.releaseDate,
+        // Only mark as "current" if both app AND HPS versions match what's deployed
+        isCurrent: versionInfo.current?.version === v.version &&
+            (!deployedHpsVersion ||
+                !v.hpsVersion ||
+                normalizeVersion(deployedHpsVersion) ===
+                    normalizeVersion(v.hpsVersion)),
+        isLatest: versionInfo.latest?.version === v.version,
+    })) || [];
+    return (_jsx(BorderBox, { title: "Rulebricks Version Manager", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [(() => {
+                    // Check if HPS has an update available (even if app version is current)
+                    const latestHps = versionInfo?.latest?.hpsVersion;
+                    const hasHpsUpdate = deployedHpsVersion &&
+                        latestHps &&
+                        normalizeVersion(deployedHpsVersion) !==
+                            normalizeVersion(latestHps);
+                    const hasAnyUpdate = versionInfo?.hasUpdate || hasHpsUpdate;
+                    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: ["Current:", " ", _jsx(Text, { color: colors.accent, children: versionInfo?.current
+                                            ? formatVersionDisplay(versionInfo.current.version)
+                                            : "Not installed" }), deployedHpsVersion && (_jsxs(Text, { color: hasHpsUpdate ? colors.accent : colors.muted, children: [" ", "(Solver: ", formatVersionDisplay(deployedHpsVersion), ")"] }))] }), _jsxs(Text, { children: ["Latest:", " ", _jsx(Text, { color: hasAnyUpdate ? colors.success : colors.accent, children: versionInfo?.latest
+                                            ? formatVersionDisplay(versionInfo.latest.version)
+                                            : "Unknown" }), versionInfo?.latest?.hpsVersion && (_jsxs(Text, { color: hasHpsUpdate ? colors.success : colors.muted, children: [" ", "(Solver:", " ", formatVersionDisplay(versionInfo.latest.hpsVersion), ")"] }))] }), hasAnyUpdate && (_jsx(Text, { color: colors.muted, dimColor: true, children: "Update available" }))] }));
+                })(), _jsxs(Box, { marginBottom: 1, paddingX: 1, borderStyle: "single", borderColor: colors.accent, alignSelf: "flex-start", children: [_jsx(Text, { children: "\uD83D\uDCDA What's new: " }), _jsx(Text, { color: colors.accent, underline: true, children: CHANGELOG_URL })] }), _jsx(Text, { bold: true, children: "Select app version to install:" }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: versionItems, onSelect: handleVersionSelect, limit: 8, itemComponent: ({ isSelected, label }) => {
+                            const vItem = versionItems.find((v) => v.label === label) || versionItems[0];
+                            // Highlight latest in green when there's an update available
+                            const isLatestWithUpdate = vItem.isLatest && !vItem.isCurrent;
+                            const labelColor = isSelected
+                                ? colors.accent
+                                : isLatestWithUpdate
+                                    ? colors.success
+                                    : undefined;
+                            return (_jsxs(Box, { children: [_jsx(Text, { color: labelColor, children: label }), vItem.hpsVersion && (_jsxs(Text, { color: isLatestWithUpdate ? colors.success : colors.muted, children: [" ", "(Solver: ", formatVersionDisplay(vItem.hpsVersion), ")"] })), vItem.isCurrent && (_jsx(Text, { color: colors.warning, children: " current" })), _jsxs(Text, { color: colors.muted, children: [" ", formatDate(vItem.date)] })] }));
+                        } }) })] }) }));
+}
+export function UpgradeCommand(props) {
+    return (_jsxs(ThemeProvider, { theme: "upgrade", children: [_jsx(Logo, {}), _jsx(UpgradeCommandInner, { ...props })] }));
+}

package/dist/components/DNSWaitScreen.d.ts

@@ -0,0 +1,9 @@
+interface DNSWaitScreenProps {
+    domain: string;
+    selfHostedSupabase: boolean;
+    namespace: string;
+    onComplete: () => void;
+    onSkip?: () => void;
+}
+export declare function DNSWaitScreen({ domain, selfHostedSupabase, namespace, onComplete, onSkip, }: DNSWaitScreenProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/DNSWaitScreen.js

@@ -0,0 +1,73 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useRef } from "react";
+import { Box, Text, useInput } from "ink";
+import InkSpinner from "ink-spinner";
+import { BorderBox, Spinner, useTheme } from "./common/index.js";
+import { getLoadBalancerAddress, getRequiredDNSRecords, checkDNSRecord, isDNSComplete, } from "../lib/dns.js";
+export function DNSWaitScreen({ domain, selfHostedSupabase, namespace, onComplete, onSkip, }) {
+    const { colors } = useTheme();
+    const [status, setStatus] = useState("loading-lb");
+    const [loadBalancer, setLoadBalancer] = useState(null);
+    const [records, setRecords] = useState([]);
+    const [error, setError] = useState(null);
+    const [pollCount, setPollCount] = useState(0);
+    // Use ref to avoid stale closure in polling interval
+    const recordsRef = useRef(records);
+    recordsRef.current = records;
+    useInput((input, key) => {
+        if (key.escape || input.toLowerCase() === "s") {
+            onSkip?.();
+        }
+        if (key.return && status === "complete") {
+            onComplete();
+        }
+    });
+    // Fetch load balancer address
+    useEffect(() => {
+        const fetchLB = async () => {
+            const result = await getLoadBalancerAddress(namespace);
+            if (!result.address) {
+                setError("Could not determine load balancer address. Make sure the deployment is running.");
+                setStatus("error");
+                return;
+            }
+            setLoadBalancer({ address: result.address, type: result.type });
+            const dnsRecords = getRequiredDNSRecords(domain, result.address, result.type, selfHostedSupabase);
+            setRecords(dnsRecords);
+            setStatus("waiting-dns");
+        };
+        fetchLB();
+    }, [domain, selfHostedSupabase, namespace]);
+    // Poll DNS records
+    useEffect(() => {
+        if (status !== "waiting-dns")
+            return;
+        const pollDNS = async () => {
+            // Use ref to get current records, avoiding stale closure
+            const currentRecords = recordsRef.current;
+            const updatedRecords = await Promise.all(currentRecords.map(async (record) => {
+                if (record.verified)
+                    return record;
+                const result = await checkDNSRecord(record.hostname, record.target);
+                return {
+                    ...record,
+                    verified: result.resolved && result.matchesTarget,
+                };
+            }));
+            setRecords(updatedRecords);
+            setPollCount((c) => c + 1);
+            if (isDNSComplete(updatedRecords)) {
+                setStatus("complete");
+            }
+        };
+        // Initial check
+        pollDNS();
+        // Poll every 5 seconds
+        const interval = setInterval(pollDNS, 5000);
+        return () => clearInterval(interval);
+    }, [status]);
+    const verifiedCount = records.filter((r) => r.verified).length;
+    return (_jsxs(BorderBox, { title: "Configure DNS Records", children: [status === "loading-lb" && (_jsx(Box, { flexDirection: "column", marginY: 1, children: _jsx(Spinner, { label: "Getting load balancer address..." }) })), status === "error" && (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { color: colors.error, bold: true, children: "\u2717 Error" }), _jsx(Text, { color: colors.error, children: error }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, children: "Press Esc to skip DNS validation" }) })] })), (status === "waiting-dns" || status === "complete") && loadBalancer && (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { bold: true, children: "Your load balancer address:" }), _jsx(Box, { marginY: 1, children: _jsx(Text, { color: colors.accent, bold: true, children: loadBalancer.address }) }), _jsx(Text, { children: "Please add the following DNS records:" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: records.map((record, idx) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [record.verified ? (_jsx(Text, { color: colors.success, children: "\u2713" })) : (_jsx(Text, { color: colors.accent, children: _jsx(InkSpinner, { type: "dots" }) })), _jsx(Text, { children: " " }), _jsx(Text, { color: record.verified ? colors.success : undefined, children: record.hostname })] }), _jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { color: colors.accent, children: record.type }), _jsx(Text, { color: colors.muted, children: " \u2192 " }), _jsx(Text, { color: colors.accent, children: record.target })] })] }, idx))) }), _jsx(Box, { marginTop: 2, children: status === "waiting-dns" ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: _jsx(Spinner, { label: `Checking DNS propagation... (${verifiedCount}/${records.length} complete)` }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.muted, dimColor: true, children: ["Poll #", pollCount, " \u2022 DNS changes can take up to 48 hours to propagate"] }) })] })) : (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.success, bold: true, children: "\u2713 All DNS records verified!" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, children: "Press Enter to continue with TLS setup" }) })] })) })] })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, dimColor: true, children: status === "complete"
+                        ? "Enter to continue"
+                        : "S or Esc to skip DNS validation (not recommended)" }) })] }));
+}

package/dist/components/Wizard/WizardContext.d.ts

@@ -0,0 +1,176 @@
+import React, { ReactNode } from "react";
+import { DeploymentConfig, CloudProvider, DatabaseType, PerformanceTier, SSOProvider, DnsProvider, LoggingSink, EmailSubjects, EmailTemplates, ProfileConfig } from "../../types/index.js";
+export interface WizardState {
+    step: number;
+    name: string;
+    infrastructureMode: "existing" | "provision" | null;
+    provider: CloudProvider | null;
+    region: string;
+    clusterName: string;
+    gcpProjectId: string;
+    azureResourceGroup: string;
+    domain: string;
+    adminEmail: string;
+    tlsEmail: string;
+    dnsProvider: DnsProvider;
+    dnsAutoManage: boolean;
+    existingExternalDns: boolean;
+    smtpHost: string;
+    smtpPort: number;
+    smtpUser: string;
+    smtpPass: string;
+    smtpFrom: string;
+    smtpFromName: string;
+    databaseType: DatabaseType | null;
+    supabaseUrl: string;
+    supabaseAnonKey: string;
+    supabaseServiceKey: string;
+    supabaseAccessToken: string;
+    supabaseProjectRef: string;
+    supabaseJwtSecret: string;
+    supabaseDbPassword: string;
+    supabaseDashboardUser: string;
+    supabaseDashboardPass: string;
+    tier: PerformanceTier | null;
+    aiEnabled: boolean;
+    openaiApiKey: string;
+    ssoEnabled: boolean;
+    ssoProvider: SSOProvider | null;
+    ssoUrl: string;
+    ssoClientId: string;
+    ssoClientSecret: string;
+    monitoringEnabled: boolean;
+    prometheusRemoteWriteUrl: string;
+    loggingSink: LoggingSink;
+    loggingBucket: string;
+    loggingRegion: string;
+    customEmailsEnabled: boolean;
+    emailSubjects: EmailSubjects;
+    emailTemplates: EmailTemplates;
+    licenseKey: string;
+    appVersion: string;
+    hpsVersion: string;
+    chartVersion: string;
+}
+type WizardAction = {
+    type: "SET_STEP";
+    step: number;
+} | {
+    type: "SET_NAME";
+    name: string;
+} | {
+    type: "SET_INFRA_MODE";
+    mode: "existing" | "provision";
+} | {
+    type: "SET_PROVIDER";
+    provider: CloudProvider;
+} | {
+    type: "SET_REGION";
+    region: string;
+} | {
+    type: "SET_CLUSTER_NAME";
+    clusterName: string;
+} | {
+    type: "SET_GCP_PROJECT";
+    projectId: string;
+} | {
+    type: "SET_AZURE_RG";
+    resourceGroup: string;
+} | {
+    type: "SET_DOMAIN";
+    domain: string;
+} | {
+    type: "SET_ADMIN_EMAIL";
+    email: string;
+} | {
+    type: "SET_TLS_EMAIL";
+    email: string;
+} | {
+    type: "SET_DNS_PROVIDER";
+    provider: DnsProvider;
+} | {
+    type: "SET_DNS_AUTO_MANAGE";
+    autoManage: boolean;
+} | {
+    type: "SET_EXISTING_EXTERNAL_DNS";
+    exists: boolean;
+} | {
+    type: "SET_SMTP";
+    config: Partial<Pick<WizardState, "smtpHost" | "smtpPort" | "smtpUser" | "smtpPass" | "smtpFrom" | "smtpFromName">>;
+} | {
+    type: "SET_DATABASE_TYPE";
+    dbType: DatabaseType;
+} | {
+    type: "SET_SUPABASE_CONFIG";
+    config: Partial<WizardState>;
+} | {
+    type: "SET_SUPABASE_SELF_HOSTED";
+    config: Partial<Pick<WizardState, "supabaseJwtSecret" | "supabaseDbPassword" | "supabaseDashboardUser" | "supabaseDashboardPass">>;
+} | {
+    type: "SET_TIER";
+    tier: PerformanceTier;
+} | {
+    type: "SET_AI_ENABLED";
+    enabled: boolean;
+} | {
+    type: "SET_OPENAI_KEY";
+    key: string;
+} | {
+    type: "SET_SSO_ENABLED";
+    enabled: boolean;
+} | {
+    type: "SET_SSO_CONFIG";
+    config: Partial<Pick<WizardState, "ssoProvider" | "ssoUrl" | "ssoClientId" | "ssoClientSecret">>;
+} | {
+    type: "SET_MONITORING";
+    enabled: boolean;
+} | {
+    type: "SET_PROMETHEUS_REMOTE_WRITE";
+    url: string;
+} | {
+    type: "SET_LOGGING_SINK";
+    sink: LoggingSink;
+} | {
+    type: "SET_LOGGING_CONFIG";
+    config: Partial<Pick<WizardState, "loggingBucket" | "loggingRegion">>;
+} | {
+    type: "SET_CUSTOM_EMAILS_ENABLED";
+    enabled: boolean;
+} | {
+    type: "SET_EMAIL_SUBJECTS";
+    subjects: Partial<EmailSubjects>;
+} | {
+    type: "SET_EMAIL_TEMPLATES";
+    templates: Partial<EmailTemplates>;
+} | {
+    type: "SET_LICENSE_KEY";
+    key: string;
+} | {
+    type: "SET_APP_VERSION";
+    appVersion: string;
+    hpsVersion: string;
+} | {
+    type: "SET_CHART_VERSION";
+    version: string;
+} | {
+    type: "NEXT_STEP";
+} | {
+    type: "PREV_STEP";
+};
+interface WizardContextValue {
+    state: WizardState;
+    dispatch: React.Dispatch<WizardAction>;
+    toConfig: () => DeploymentConfig | null;
+    skipToStep: (stepId: string) => void;
+    profile: ProfileConfig | null;
+    /** Suggests a domain based on the profile's domain suffix and deployment name */
+    suggestDomain: (name: string) => string;
+}
+interface WizardProviderProps {
+    children: ReactNode;
+    initialName?: string;
+    profile?: ProfileConfig | null;
+}
+export declare function WizardProvider({ children, initialName, profile, }: WizardProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useWizard(): WizardContextValue;
+export {};