@retiregolden/engine 0.1.0

package/dist/model/plan.d.ts

@@ -0,0 +1,3108 @@
+/**
+ * Plan schema v1 — the v2 domain model of a household's finances.
+ *
+ * Zod schemas are the source of truth: types are inferred from them, and the
+ * same schemas validate IndexedDB reads, JSON imports, and migration output.
+ * Forward-looking fields (strategies, scenarios) are schema-complete before
+ * their engines exist so early plans survive later phases via migrations.
+ *
+ * @see DOCS/architecture.md (data model)
+ * @see DOCS/features/README.md
+ */
+import { z } from 'zod';
+export declare const CURRENT_PLAN_SCHEMA_VERSION = 1;
+export declare const personSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    dob: z.ZodString;
+    sex: z.ZodEnum<{
+        female: "female";
+        male: "male";
+        average: "average";
+    }>;
+    retirementAge: z.ZodNullable<z.ZodNumber>;
+    longevity: z.ZodObject<{
+        planningAge: z.ZodNumber;
+        source: z.ZodEnum<{
+            model: "model";
+            manual: "manual";
+            percentile: "percentile";
+        }>;
+        percentile: z.ZodOptional<z.ZodObject<{
+            pct: z.ZodNumber;
+            joint: z.ZodBoolean;
+            healthMultiplier: z.ZodOptional<z.ZodNumber>;
+            partnerHealthMultiplier: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type Person = z.infer<typeof personSchema>;
+/** Relocation to a new state of residence starting in `fromYear`. */
+export declare const stateMoveSchema: z.ZodObject<{
+    fromYear: z.ZodNumber;
+    fromMonth: z.ZodDefault<z.ZodNumber>;
+    state: z.ZodString;
+}, z.core.$strip>;
+export type StateMove = z.infer<typeof stateMoveSchema>;
+export declare const householdSchema: z.ZodObject<{
+    filingStatus: z.ZodEnum<{
+        single: "single";
+        marriedFilingJointly: "marriedFilingJointly";
+    }>;
+    hasQualifyingDependent: z.ZodDefault<z.ZodBoolean>;
+    state: z.ZodString;
+    stateMoves: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        fromYear: z.ZodNumber;
+        fromMonth: z.ZodDefault<z.ZodNumber>;
+        state: z.ZodString;
+    }, z.core.$strip>>>;
+    capitalLossCarryforward: z.ZodDefault<z.ZodNumber>;
+    people: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        dob: z.ZodString;
+        sex: z.ZodEnum<{
+            female: "female";
+            male: "male";
+            average: "average";
+        }>;
+        retirementAge: z.ZodNullable<z.ZodNumber>;
+        longevity: z.ZodObject<{
+            planningAge: z.ZodNumber;
+            source: z.ZodEnum<{
+                model: "model";
+                manual: "manual";
+                percentile: "percentile";
+            }>;
+            percentile: z.ZodOptional<z.ZodObject<{
+                pct: z.ZodNumber;
+                joint: z.ZodBoolean;
+                healthMultiplier: z.ZodOptional<z.ZodNumber>;
+                partnerHealthMultiplier: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Household = z.infer<typeof householdSchema>;
+/** State of residence in a given year: the latest move at/Before `year`, else the base state. */
+export declare function stateForYear(household: Household, year: number): string;
+export interface StateResidencySegment {
+    state: string;
+    months: number;
+}
+/** State residency allocation in a tax year, splitting the move year by month. */
+export declare function stateResidencySegmentsForYear(household: Household, year: number): StateResidencySegment[];
+/** The v1 class set; alternatives arrive later. Order matters (weight vectors + correlation matrix). */
+export declare const ASSET_CLASS_IDS: readonly ["usStocks", "intlStocks", "bonds", "cash"];
+export type AssetClassId = (typeof ASSET_CLASS_IDS)[number];
+/**
+ * Percent of the account in each class, summing to 100. Kept as percents (not
+ * fractions) to match every other UI-facing rate in the schema.
+ */
+export declare const allocationWeightsSchema: z.ZodObject<{
+    usStocks: z.ZodDefault<z.ZodNumber>;
+    intlStocks: z.ZodDefault<z.ZodNumber>;
+    bonds: z.ZodDefault<z.ZodNumber>;
+    cash: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type AllocationWeights = z.infer<typeof allocationWeightsSchema>;
+/**
+ * Opt-in per-account allocation policy (account-level; household roll-up is
+ * derived). Absent = today's single-return behavior, unchanged. When present,
+ * it supersedes the account's `annualReturnPct`: growth is the class blend
+ * from Assumptions-level class parameters. Glidepaths compile to per-year
+ * target weights: 'linear' interpolates from → to between its years, 'staged'
+ * is a step function, 'custom' interpolates between explicit year targets.
+ */
+export declare const assetAllocationPolicySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    weights: z.ZodObject<{
+        usStocks: z.ZodDefault<z.ZodNumber>;
+        intlStocks: z.ZodDefault<z.ZodNumber>;
+        bonds: z.ZodDefault<z.ZodNumber>;
+        cash: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    rebalancing: z.ZodDefault<z.ZodEnum<{
+        annual: "annual";
+        none: "none";
+    }>>;
+    mode: z.ZodLiteral<"static">;
+}, z.core.$strip>, z.ZodObject<{
+    from: z.ZodObject<{
+        usStocks: z.ZodDefault<z.ZodNumber>;
+        intlStocks: z.ZodDefault<z.ZodNumber>;
+        bonds: z.ZodDefault<z.ZodNumber>;
+        cash: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    to: z.ZodObject<{
+        usStocks: z.ZodDefault<z.ZodNumber>;
+        intlStocks: z.ZodDefault<z.ZodNumber>;
+        bonds: z.ZodDefault<z.ZodNumber>;
+        cash: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    startYear: z.ZodNumber;
+    endYear: z.ZodNumber;
+    rebalancing: z.ZodDefault<z.ZodEnum<{
+        annual: "annual";
+        none: "none";
+    }>>;
+    mode: z.ZodLiteral<"linear">;
+}, z.core.$strip>, z.ZodObject<{
+    stages: z.ZodArray<z.ZodObject<{
+        fromYear: z.ZodNumber;
+        weights: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    rebalancing: z.ZodDefault<z.ZodEnum<{
+        annual: "annual";
+        none: "none";
+    }>>;
+    mode: z.ZodLiteral<"staged">;
+}, z.core.$strip>, z.ZodObject<{
+    targets: z.ZodArray<z.ZodObject<{
+        year: z.ZodNumber;
+        weights: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    rebalancing: z.ZodDefault<z.ZodEnum<{
+        annual: "annual";
+        none: "none";
+    }>>;
+    mode: z.ZodLiteral<"custom">;
+}, z.core.$strip>], "mode">;
+export type AssetAllocationPolicy = z.infer<typeof assetAllocationPolicySchema>;
+export declare const assetClassParamOverridesSchema: z.ZodObject<{
+    usStocks: z.ZodOptional<z.ZodObject<{
+        returnPct: z.ZodOptional<z.ZodNumber>;
+        volatilityPct: z.ZodOptional<z.ZodNumber>;
+        interestYieldPct: z.ZodOptional<z.ZodNumber>;
+        dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+        qualifiedRatioPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    intlStocks: z.ZodOptional<z.ZodObject<{
+        returnPct: z.ZodOptional<z.ZodNumber>;
+        volatilityPct: z.ZodOptional<z.ZodNumber>;
+        interestYieldPct: z.ZodOptional<z.ZodNumber>;
+        dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+        qualifiedRatioPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    bonds: z.ZodOptional<z.ZodObject<{
+        returnPct: z.ZodOptional<z.ZodNumber>;
+        volatilityPct: z.ZodOptional<z.ZodNumber>;
+        interestYieldPct: z.ZodOptional<z.ZodNumber>;
+        dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+        qualifiedRatioPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    cash: z.ZodOptional<z.ZodObject<{
+        returnPct: z.ZodOptional<z.ZodNumber>;
+        volatilityPct: z.ZodOptional<z.ZodNumber>;
+        interestYieldPct: z.ZodOptional<z.ZodNumber>;
+        dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+        qualifiedRatioPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AssetClassParamOverrides = z.infer<typeof assetClassParamOverridesSchema>;
+/**
+ * Where an account passes at the end of the plan, for the after-tax estate
+ * metric. Absent = the legacy default: pre-tax (traditional) and non-spouse HSA
+ * balances are taxed at the flat heir rate, everything else passes untaxed.
+ * When set:
+ *  - 'spouse'    — passes to a surviving spouse untaxed (rollover); no heir tax.
+ *  - 'nonSpouse' — a non-spouse heir; pre-tax balances (traditional, non-spouse
+ *                  HSA) are taxed at the account class's heir rate, while Roth,
+ *                  taxable (stepped-up at death), and cash pass untaxed.
+ *  - 'charity'   — `charityPct` of the ending balance passes to charity fully
+ *                  untaxed (a charitable bequest / IRA-to-charity effect); the
+ *                  remainder follows the non-spouse heir rules.
+ * The HSA's older `beneficiary` field remains a shorthand for spouse/nonSpouse;
+ * when both are present this field wins.
+ */
+export declare const estateBeneficiarySchema: z.ZodObject<{
+    destination: z.ZodEnum<{
+        spouse: "spouse";
+        nonSpouse: "nonSpouse";
+        charity: "charity";
+    }>;
+    charityPct: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type EstateBeneficiary = z.infer<typeof estateBeneficiarySchema>;
+export declare const contributionPhaseSchema: z.ZodObject<{
+    annualAmount: z.ZodNumber;
+    fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    escalationPct: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type ContributionPhase = z.infer<typeof contributionPhaseSchema>;
+export declare const employerMatchSchema: z.ZodObject<{
+    matchPct: z.ZodNumber;
+    capPctOfPay: z.ZodNumber;
+}, z.core.$strip>;
+export type EmployerMatch = z.infer<typeof employerMatchSchema>;
+export declare const taxableAccountSchema: z.ZodObject<{
+    type: z.ZodLiteral<"taxable">;
+    balance: z.ZodNumber;
+    costBasis: z.ZodNumber;
+    interestYieldPct: z.ZodOptional<z.ZodNumber>;
+    dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+    qualifiedRatio: z.ZodOptional<z.ZodNumber>;
+    reinvestDividends: z.ZodOptional<z.ZodBoolean>;
+    allocation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        weights: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"static">;
+    }, z.core.$strip>, z.ZodObject<{
+        from: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        to: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        startYear: z.ZodNumber;
+        endYear: z.ZodNumber;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"linear">;
+    }, z.core.$strip>, z.ZodObject<{
+        stages: z.ZodArray<z.ZodObject<{
+            fromYear: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"staged">;
+    }, z.core.$strip>, z.ZodObject<{
+        targets: z.ZodArray<z.ZodObject<{
+            year: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"custom">;
+    }, z.core.$strip>], "mode">>;
+    annualContribution: z.ZodNumber;
+    contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        annualAmount: z.ZodNumber;
+        fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        escalationPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const equityCompAccountSchema: z.ZodObject<{
+    type: z.ZodLiteral<"equityComp">;
+    balance: z.ZodNumber;
+    costBasis: z.ZodNumber;
+    annualContribution: z.ZodNumber;
+    contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        annualAmount: z.ZodNumber;
+        fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        escalationPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    vestingMode: z.ZodEnum<{
+        final: "final";
+        cliff: "cliff";
+    }>;
+    vestDate: z.ZodNullable<z.ZodString>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * 72(t) SEPP election (roadmap V8). Penalty-free substantially-equal periodic
+ * payments from this account starting at `startAge`, for the longer of 5 years
+ * or until 59½. Optional — omitted means no SEPP, so no migration is needed.
+ */
+export declare const seppElectionSchema: z.ZodObject<{
+    startAge: z.ZodNumber;
+    method: z.ZodEnum<{
+        rmd: "rmd";
+        amortization: "amortization";
+    }>;
+}, z.core.$strip>;
+/**
+ * Inherited (beneficiary) account under the SECURE Act 10-year rule (roadmap
+ * V8). Optional — omitted means a normal owned account, so no migration needed.
+ */
+export declare const inheritedAccountSchema: z.ZodObject<{
+    ownerDeathYear: z.ZodNumber;
+    decedentHadStartedRmds: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const traditionalAccountSchema: z.ZodObject<{
+    type: z.ZodLiteral<"traditional">;
+    kind: z.ZodEnum<{
+        ira: "ira";
+        employer: "employer";
+    }>;
+    balance: z.ZodNumber;
+    annualContribution: z.ZodNumber;
+    inherited: z.ZodOptional<z.ZodObject<{
+        ownerDeathYear: z.ZodNumber;
+        decedentHadStartedRmds: z.ZodBoolean;
+    }, z.core.$strip>>;
+    nondeductibleBasis: z.ZodOptional<z.ZodNumber>;
+    spouseSoleBeneficiary: z.ZodOptional<z.ZodBoolean>;
+    sepp: z.ZodOptional<z.ZodObject<{
+        startAge: z.ZodNumber;
+        method: z.ZodEnum<{
+            rmd: "rmd";
+            amortization: "amortization";
+        }>;
+    }, z.core.$strip>>;
+    employerMatch: z.ZodOptional<z.ZodObject<{
+        matchPct: z.ZodNumber;
+        capPctOfPay: z.ZodNumber;
+    }, z.core.$strip>>;
+    contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        annualAmount: z.ZodNumber;
+        fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        escalationPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    allocation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        weights: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"static">;
+    }, z.core.$strip>, z.ZodObject<{
+        from: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        to: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        startYear: z.ZodNumber;
+        endYear: z.ZodNumber;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"linear">;
+    }, z.core.$strip>, z.ZodObject<{
+        stages: z.ZodArray<z.ZodObject<{
+            fromYear: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"staged">;
+    }, z.core.$strip>, z.ZodObject<{
+        targets: z.ZodArray<z.ZodObject<{
+            year: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"custom">;
+    }, z.core.$strip>], "mode">>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const rothAccountSchema: z.ZodObject<{
+    type: z.ZodLiteral<"roth">;
+    kind: z.ZodEnum<{
+        ira: "ira";
+        employer: "employer";
+    }>;
+    balance: z.ZodNumber;
+    annualContribution: z.ZodNumber;
+    contributionBasis: z.ZodOptional<z.ZodNumber>;
+    employerMatch: z.ZodOptional<z.ZodObject<{
+        matchPct: z.ZodNumber;
+        capPctOfPay: z.ZodNumber;
+    }, z.core.$strip>>;
+    contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        annualAmount: z.ZodNumber;
+        fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        escalationPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    allocation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        weights: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"static">;
+    }, z.core.$strip>, z.ZodObject<{
+        from: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        to: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        startYear: z.ZodNumber;
+        endYear: z.ZodNumber;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"linear">;
+    }, z.core.$strip>, z.ZodObject<{
+        stages: z.ZodArray<z.ZodObject<{
+            fromYear: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"staged">;
+    }, z.core.$strip>, z.ZodObject<{
+        targets: z.ZodArray<z.ZodObject<{
+            year: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"custom">;
+    }, z.core.$strip>], "mode">>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const hsaAccountSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hsa">;
+    balance: z.ZodNumber;
+    annualContribution: z.ZodNumber;
+    contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        annualAmount: z.ZodNumber;
+        fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        escalationPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    withdrawalTreatment: z.ZodOptional<z.ZodEnum<{
+        assumeAllQualified: "assumeAllQualified";
+        capByMedicalExpenses: "capByMedicalExpenses";
+    }>>;
+    reimburseLater: z.ZodOptional<z.ZodBoolean>;
+    beneficiary: z.ZodOptional<z.ZodEnum<{
+        spouse: "spouse";
+        nonSpouse: "nonSpouse";
+    }>>;
+    allocation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        weights: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"static">;
+    }, z.core.$strip>, z.ZodObject<{
+        from: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        to: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        startYear: z.ZodNumber;
+        endYear: z.ZodNumber;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"linear">;
+    }, z.core.$strip>, z.ZodObject<{
+        stages: z.ZodArray<z.ZodObject<{
+            fromYear: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"staged">;
+    }, z.core.$strip>, z.ZodObject<{
+        targets: z.ZodArray<z.ZodObject<{
+            year: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"custom">;
+    }, z.core.$strip>], "mode">>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const cashAccountSchema: z.ZodObject<{
+    type: z.ZodLiteral<"cash">;
+    balance: z.ZodNumber;
+    annualContribution: z.ZodNumber;
+    contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        annualAmount: z.ZodNumber;
+        fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        escalationPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Optional lump-sum election facts on a pension (annuity-pension-and-home-
+ * equity decisions, step 3). `lumpSumOffer` records the offer for the decision
+ * view (PV comparison, sensitivity table) and the pension-election insight;
+ * it changes nothing in the ledger by itself. `lumpSumElection` commutes the
+ * pension: in the election year the offer amount rolls over tax-free into the
+ * named traditional account (a direct rollover, so no withholding or income),
+ * and the pension never pays its annuity. Both are additive and optional, so
+ * pre-existing plans are byte-identical.
+ */
+export declare const pensionLumpSumOfferSchema: z.ZodObject<{
+    amount: z.ZodNumber;
+    electionYear: z.ZodNumber;
+}, z.core.$strip>;
+export type PensionLumpSumOffer = z.infer<typeof pensionLumpSumOfferSchema>;
+export declare const pensionLumpSumElectionSchema: z.ZodObject<{
+    rolloverAccountId: z.ZodString;
+}, z.core.$strip>;
+export declare const pensionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pension">;
+    source: z.ZodOptional<z.ZodEnum<{
+        private: "private";
+        public: "public";
+    }>>;
+    startAge: z.ZodNumber;
+    monthlyAmount: z.ZodNumber;
+    colaPct: z.ZodNumber;
+    survivorPct: z.ZodNumber;
+    lumpSumOffer: z.ZodOptional<z.ZodObject<{
+        amount: z.ZodNumber;
+        electionYear: z.ZodNumber;
+    }, z.core.$strip>>;
+    lumpSumElection: z.ZodOptional<z.ZodObject<{
+        rolloverAccountId: z.ZodString;
+    }, z.core.$strip>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Optional purchase event that funds an annuity by trading a premium out of a
+ * liquid or qualified account (guaranteed-income-and-estate-depth). Absent = the
+ * annuity is an already-owned income stream (legacy behavior). When present:
+ *  - the premium is withdrawn from `fundingAccountId` in `year` — a transfer,
+ *    not spending, so it is never counted against the spending target. Cash and
+ *    qualified (traditional) sources move at book value; a taxable/equity-comp
+ *    source liquidates the position and realizes its gains pro-rata (folded into
+ *    that year's realized capital gains), exactly like any other sale;
+ *  - 'nonQualified' (cash/taxable-funded): payouts are taxed by the IRS Pub 939
+ *    exclusion ratio — the premium is the investment in the contract — so the
+ *    account's `taxablePct` is derived from the ratio and the stored value is a
+ *    display fallback only;
+ *  - 'qualified' (traditional-funded): payouts are fully ordinary income, and
+ *    because the premium leaves the traditional balance, future RMDs shrink
+ *    automatically. `qlac` marks a deferred-start qualified contract whose
+ *    premium is held to the QLAC statutory cap (a warning fires above it).
+ */
+export declare const annuityPurchaseSchema: z.ZodObject<{
+    year: z.ZodNumber;
+    premium: z.ZodNumber;
+    fundingAccountId: z.ZodString;
+    taxQualification: z.ZodEnum<{
+        nonQualified: "nonQualified";
+        qualified: "qualified";
+    }>;
+    qlac: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AnnuityPurchase = z.infer<typeof annuityPurchaseSchema>;
+/**
+ * Payout form of an annuity contract (annuity-pension-and-home-equity
+ * decisions, step 1). Absent = 'lifeOnly', the legacy behavior — payments
+ * stop at the owner's death — so pre-existing plans are byte-identical.
+ *  - 'periodCertain': life annuity with an N-year guarantee measured from the
+ *    payment start age. If the owner dies inside the guarantee window, the
+ *    remaining certain payments continue to the household (beneficiary); after
+ *    the window the annuity is life-contingent as usual.
+ *  - 'jointSurvivor': payments continue to the other household member at
+ *    `survivorPct` of the full amount after the owner's death, for the
+ *    survivor's lifetime. Requires a two-person household.
+ * Both forms extend the IRS Pub 939 exclusion-ratio math for a non-qualified
+ * purchase (see engine/projection/annuityForms.ts for the method and its
+ * documented approximations).
+ */
+export declare const annuityPayoutFormSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"lifeOnly">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"periodCertain">;
+    certainYears: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"jointSurvivor">;
+    survivorPct: z.ZodNumber;
+}, z.core.$strip>], "kind">;
+export type AnnuityPayoutForm = z.infer<typeof annuityPayoutFormSchema>;
+export declare const annuitySchema: z.ZodObject<{
+    type: z.ZodLiteral<"annuity">;
+    startAge: z.ZodNumber;
+    monthlyAmount: z.ZodNumber;
+    colaPct: z.ZodNumber;
+    taxablePct: z.ZodNumber;
+    purchase: z.ZodOptional<z.ZodObject<{
+        year: z.ZodNumber;
+        premium: z.ZodNumber;
+        fundingAccountId: z.ZodString;
+        taxQualification: z.ZodEnum<{
+            nonQualified: "nonQualified";
+            qualified: "qualified";
+        }>;
+        qlac: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    payoutForm: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"lifeOnly">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"periodCertain">;
+        certainYears: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"jointSurvivor">;
+        survivorPct: z.ZodNumber;
+    }, z.core.$strip>], "kind">>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Opt-in HECM (reverse-mortgage) line of credit on an owned home
+ * (annuity-pension-and-home-equity decisions, step 4). Models Pfau's
+ * buffer-asset strategy: open the line early, let the unused credit grow, and
+ * draw tax-free loan proceeds either after down market years ('coordinated')
+ * or only once the portfolio is exhausted ('lastResort'). The loan balance
+ * accrues at the same growth rate; payoff at sale or the end of the plan is
+ * non-recourse (never more than the home's value). Absent = no HECM — plans
+ * without one are unchanged.
+ */
+export declare const hecmLineOfCreditSchema: z.ZodObject<{
+    openYear: z.ZodNumber;
+    principalLimitPct: z.ZodOptional<z.ZodNumber>;
+    growthRatePct: z.ZodNumber;
+    upfrontCostPct: z.ZodOptional<z.ZodNumber>;
+    drawPolicy: z.ZodEnum<{
+        coordinated: "coordinated";
+        lastResort: "lastResort";
+    }>;
+}, z.core.$strip>;
+export type HecmLineOfCredit = z.infer<typeof hecmLineOfCreditSchema>;
+export declare const propertySchema: z.ZodObject<{
+    type: z.ZodLiteral<"property">;
+    value: z.ZodNumber;
+    plannedSaleYear: z.ZodNullable<z.ZodNumber>;
+    expectedNetProceeds: z.ZodNullable<z.ZodNumber>;
+    costBasis: z.ZodOptional<z.ZodNumber>;
+    sellingCostPct: z.ZodOptional<z.ZodNumber>;
+    primaryResidence: z.ZodOptional<z.ZodBoolean>;
+    depreciationRecapture: z.ZodOptional<z.ZodNumber>;
+    propertyTaxAnnual: z.ZodOptional<z.ZodNumber>;
+    insuranceAnnual: z.ZodOptional<z.ZodNumber>;
+    hecm: z.ZodOptional<z.ZodObject<{
+        openYear: z.ZodNumber;
+        principalLimitPct: z.ZodOptional<z.ZodNumber>;
+        growthRatePct: z.ZodNumber;
+        upfrontCostPct: z.ZodOptional<z.ZodNumber>;
+        drawPolicy: z.ZodEnum<{
+            coordinated: "coordinated";
+            lastResort: "lastResort";
+        }>;
+    }, z.core.$strip>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const debtSchema: z.ZodObject<{
+    type: z.ZodLiteral<"debt">;
+    balance: z.ZodNumber;
+    interestPct: z.ZodNumber;
+    monthlyPayment: z.ZodNumber;
+    payoffYear: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const accountSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"taxable">;
+    balance: z.ZodNumber;
+    costBasis: z.ZodNumber;
+    interestYieldPct: z.ZodOptional<z.ZodNumber>;
+    dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+    qualifiedRatio: z.ZodOptional<z.ZodNumber>;
+    reinvestDividends: z.ZodOptional<z.ZodBoolean>;
+    allocation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        weights: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"static">;
+    }, z.core.$strip>, z.ZodObject<{
+        from: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        to: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        startYear: z.ZodNumber;
+        endYear: z.ZodNumber;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"linear">;
+    }, z.core.$strip>, z.ZodObject<{
+        stages: z.ZodArray<z.ZodObject<{
+            fromYear: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"staged">;
+    }, z.core.$strip>, z.ZodObject<{
+        targets: z.ZodArray<z.ZodObject<{
+            year: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"custom">;
+    }, z.core.$strip>], "mode">>;
+    annualContribution: z.ZodNumber;
+    contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        annualAmount: z.ZodNumber;
+        fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        escalationPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"equityComp">;
+    balance: z.ZodNumber;
+    costBasis: z.ZodNumber;
+    annualContribution: z.ZodNumber;
+    contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        annualAmount: z.ZodNumber;
+        fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        escalationPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    vestingMode: z.ZodEnum<{
+        final: "final";
+        cliff: "cliff";
+    }>;
+    vestDate: z.ZodNullable<z.ZodString>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"traditional">;
+    kind: z.ZodEnum<{
+        ira: "ira";
+        employer: "employer";
+    }>;
+    balance: z.ZodNumber;
+    annualContribution: z.ZodNumber;
+    inherited: z.ZodOptional<z.ZodObject<{
+        ownerDeathYear: z.ZodNumber;
+        decedentHadStartedRmds: z.ZodBoolean;
+    }, z.core.$strip>>;
+    nondeductibleBasis: z.ZodOptional<z.ZodNumber>;
+    spouseSoleBeneficiary: z.ZodOptional<z.ZodBoolean>;
+    sepp: z.ZodOptional<z.ZodObject<{
+        startAge: z.ZodNumber;
+        method: z.ZodEnum<{
+            rmd: "rmd";
+            amortization: "amortization";
+        }>;
+    }, z.core.$strip>>;
+    employerMatch: z.ZodOptional<z.ZodObject<{
+        matchPct: z.ZodNumber;
+        capPctOfPay: z.ZodNumber;
+    }, z.core.$strip>>;
+    contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        annualAmount: z.ZodNumber;
+        fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        escalationPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    allocation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        weights: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"static">;
+    }, z.core.$strip>, z.ZodObject<{
+        from: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        to: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        startYear: z.ZodNumber;
+        endYear: z.ZodNumber;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"linear">;
+    }, z.core.$strip>, z.ZodObject<{
+        stages: z.ZodArray<z.ZodObject<{
+            fromYear: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"staged">;
+    }, z.core.$strip>, z.ZodObject<{
+        targets: z.ZodArray<z.ZodObject<{
+            year: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"custom">;
+    }, z.core.$strip>], "mode">>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"roth">;
+    kind: z.ZodEnum<{
+        ira: "ira";
+        employer: "employer";
+    }>;
+    balance: z.ZodNumber;
+    annualContribution: z.ZodNumber;
+    contributionBasis: z.ZodOptional<z.ZodNumber>;
+    employerMatch: z.ZodOptional<z.ZodObject<{
+        matchPct: z.ZodNumber;
+        capPctOfPay: z.ZodNumber;
+    }, z.core.$strip>>;
+    contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        annualAmount: z.ZodNumber;
+        fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        escalationPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    allocation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        weights: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"static">;
+    }, z.core.$strip>, z.ZodObject<{
+        from: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        to: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        startYear: z.ZodNumber;
+        endYear: z.ZodNumber;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"linear">;
+    }, z.core.$strip>, z.ZodObject<{
+        stages: z.ZodArray<z.ZodObject<{
+            fromYear: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"staged">;
+    }, z.core.$strip>, z.ZodObject<{
+        targets: z.ZodArray<z.ZodObject<{
+            year: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"custom">;
+    }, z.core.$strip>], "mode">>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"hsa">;
+    balance: z.ZodNumber;
+    annualContribution: z.ZodNumber;
+    contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        annualAmount: z.ZodNumber;
+        fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        escalationPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    withdrawalTreatment: z.ZodOptional<z.ZodEnum<{
+        assumeAllQualified: "assumeAllQualified";
+        capByMedicalExpenses: "capByMedicalExpenses";
+    }>>;
+    reimburseLater: z.ZodOptional<z.ZodBoolean>;
+    beneficiary: z.ZodOptional<z.ZodEnum<{
+        spouse: "spouse";
+        nonSpouse: "nonSpouse";
+    }>>;
+    allocation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        weights: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"static">;
+    }, z.core.$strip>, z.ZodObject<{
+        from: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        to: z.ZodObject<{
+            usStocks: z.ZodDefault<z.ZodNumber>;
+            intlStocks: z.ZodDefault<z.ZodNumber>;
+            bonds: z.ZodDefault<z.ZodNumber>;
+            cash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        startYear: z.ZodNumber;
+        endYear: z.ZodNumber;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"linear">;
+    }, z.core.$strip>, z.ZodObject<{
+        stages: z.ZodArray<z.ZodObject<{
+            fromYear: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"staged">;
+    }, z.core.$strip>, z.ZodObject<{
+        targets: z.ZodArray<z.ZodObject<{
+            year: z.ZodNumber;
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        rebalancing: z.ZodDefault<z.ZodEnum<{
+            annual: "annual";
+            none: "none";
+        }>>;
+        mode: z.ZodLiteral<"custom">;
+    }, z.core.$strip>], "mode">>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"cash">;
+    balance: z.ZodNumber;
+    annualContribution: z.ZodNumber;
+    contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        annualAmount: z.ZodNumber;
+        fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        escalationPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"pension">;
+    source: z.ZodOptional<z.ZodEnum<{
+        private: "private";
+        public: "public";
+    }>>;
+    startAge: z.ZodNumber;
+    monthlyAmount: z.ZodNumber;
+    colaPct: z.ZodNumber;
+    survivorPct: z.ZodNumber;
+    lumpSumOffer: z.ZodOptional<z.ZodObject<{
+        amount: z.ZodNumber;
+        electionYear: z.ZodNumber;
+    }, z.core.$strip>>;
+    lumpSumElection: z.ZodOptional<z.ZodObject<{
+        rolloverAccountId: z.ZodString;
+    }, z.core.$strip>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"annuity">;
+    startAge: z.ZodNumber;
+    monthlyAmount: z.ZodNumber;
+    colaPct: z.ZodNumber;
+    taxablePct: z.ZodNumber;
+    purchase: z.ZodOptional<z.ZodObject<{
+        year: z.ZodNumber;
+        premium: z.ZodNumber;
+        fundingAccountId: z.ZodString;
+        taxQualification: z.ZodEnum<{
+            nonQualified: "nonQualified";
+            qualified: "qualified";
+        }>;
+        qlac: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    payoutForm: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"lifeOnly">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"periodCertain">;
+        certainYears: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"jointSurvivor">;
+        survivorPct: z.ZodNumber;
+    }, z.core.$strip>], "kind">>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"property">;
+    value: z.ZodNumber;
+    plannedSaleYear: z.ZodNullable<z.ZodNumber>;
+    expectedNetProceeds: z.ZodNullable<z.ZodNumber>;
+    costBasis: z.ZodOptional<z.ZodNumber>;
+    sellingCostPct: z.ZodOptional<z.ZodNumber>;
+    primaryResidence: z.ZodOptional<z.ZodBoolean>;
+    depreciationRecapture: z.ZodOptional<z.ZodNumber>;
+    propertyTaxAnnual: z.ZodOptional<z.ZodNumber>;
+    insuranceAnnual: z.ZodOptional<z.ZodNumber>;
+    hecm: z.ZodOptional<z.ZodObject<{
+        openYear: z.ZodNumber;
+        principalLimitPct: z.ZodOptional<z.ZodNumber>;
+        growthRatePct: z.ZodNumber;
+        upfrontCostPct: z.ZodOptional<z.ZodNumber>;
+        drawPolicy: z.ZodEnum<{
+            coordinated: "coordinated";
+            lastResort: "lastResort";
+        }>;
+    }, z.core.$strip>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"debt">;
+    balance: z.ZodNumber;
+    interestPct: z.ZodNumber;
+    monthlyPayment: z.ZodNumber;
+    payoffYear: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    ownerPersonId: z.ZodNullable<z.ZodString>;
+    annualReturnPct: z.ZodNullable<z.ZodNumber>;
+    estateBeneficiary: z.ZodOptional<z.ZodObject<{
+        destination: z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+            charity: "charity";
+        }>;
+        charityPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "type">;
+export type Account = z.infer<typeof accountSchema>;
+export type AccountType = Account['type'];
+export declare const ltcPolicySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"ltc">;
+    id: z.ZodString;
+    name: z.ZodString;
+    owner: z.ZodString;
+    annualPremium: z.ZodNumber;
+    premiumMode: z.ZodEnum<{
+        lifetime: "lifetime";
+        paidUp: "paidUp";
+        untilAge: "untilAge";
+    }>;
+    premiumEndAge: z.ZodOptional<z.ZodNumber>;
+    benefitMonthly: z.ZodNumber;
+    benefitPeriodYears: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"lifetime">]>;
+    eliminationPeriodDays: z.ZodNumber;
+    inflationRiderPct: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type LtcPolicy = z.infer<typeof ltcPolicySchema>;
+export declare const permanentLifePolicySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"permanentLife">;
+    id: z.ZodString;
+    name: z.ZodString;
+    insured: z.ZodString;
+    beneficiary: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"estate">]>;
+    annualPremium: z.ZodNumber;
+    premiumMode: z.ZodEnum<{
+        lifetime: "lifetime";
+        paidUp: "paidUp";
+        untilAge: "untilAge";
+    }>;
+    premiumEndAge: z.ZodOptional<z.ZodNumber>;
+    deathBenefit: z.ZodNumber;
+    cashValue: z.ZodNumber;
+    cashValueMode: z.ZodEnum<{
+        flatRate: "flatRate";
+        schedule: "schedule";
+    }>;
+    cashValueGrowthPct: z.ZodOptional<z.ZodNumber>;
+    cashValueSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        age: z.ZodNumber;
+        value: z.ZodNumber;
+    }, z.core.$strip>>>;
+    dividendOption: z.ZodOptional<z.ZodEnum<{
+        cash: "cash";
+        reducePremium: "reducePremium";
+        paidUpAdditions: "paidUpAdditions";
+    }>>;
+}, z.core.$strip>;
+export type PermanentLifePolicy = z.infer<typeof permanentLifePolicySchema>;
+export declare const insurancePolicySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"ltc">;
+    id: z.ZodString;
+    name: z.ZodString;
+    owner: z.ZodString;
+    annualPremium: z.ZodNumber;
+    premiumMode: z.ZodEnum<{
+        lifetime: "lifetime";
+        paidUp: "paidUp";
+        untilAge: "untilAge";
+    }>;
+    premiumEndAge: z.ZodOptional<z.ZodNumber>;
+    benefitMonthly: z.ZodNumber;
+    benefitPeriodYears: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"lifetime">]>;
+    eliminationPeriodDays: z.ZodNumber;
+    inflationRiderPct: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"permanentLife">;
+    id: z.ZodString;
+    name: z.ZodString;
+    insured: z.ZodString;
+    beneficiary: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"estate">]>;
+    annualPremium: z.ZodNumber;
+    premiumMode: z.ZodEnum<{
+        lifetime: "lifetime";
+        paidUp: "paidUp";
+        untilAge: "untilAge";
+    }>;
+    premiumEndAge: z.ZodOptional<z.ZodNumber>;
+    deathBenefit: z.ZodNumber;
+    cashValue: z.ZodNumber;
+    cashValueMode: z.ZodEnum<{
+        flatRate: "flatRate";
+        schedule: "schedule";
+    }>;
+    cashValueGrowthPct: z.ZodOptional<z.ZodNumber>;
+    cashValueSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        age: z.ZodNumber;
+        value: z.ZodNumber;
+    }, z.core.$strip>>>;
+    dividendOption: z.ZodOptional<z.ZodEnum<{
+        cash: "cash";
+        reducePremium: "reducePremium";
+        paidUpAdditions: "paidUpAdditions";
+    }>>;
+}, z.core.$strip>], "kind">;
+export type InsurancePolicy = z.infer<typeof insurancePolicySchema>;
+/**
+ * A deterministic late-life care episode: a spending spike (today's dollars,
+ * additive to baseline spending) that an LTC policy on the same person offsets.
+ * The "de-risking baseline" the policy is measured against (V6 §3).
+ */
+export declare const careEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    personId: z.ZodString;
+    startAge: z.ZodNumber;
+    durationYears: z.ZodNumber;
+    annualCost: z.ZodNumber;
+}, z.core.$strip>;
+export type CareEvent = z.infer<typeof careEventSchema>;
+/**
+ * A TIPS ladder paying a level real income over a calendar window — the plan
+ * artifact behind a Social Security bridge or an essential-spending floor.
+ * Rungs are solved by the engine from the embedded real-yield curve
+ * (`engine/ladder/ladderMath.ts`); the plan stores only the intent (target
+ * income + window + optional purchase), so a curve refresh re-quotes the same
+ * ladder. Cash flows run through the ledger with TIPS taxation: coupon income
+ * and the annual inflation accretion (phantom OID) are federal ordinary income
+ * but exempt from state tax; maturing principal is a tax-free return of
+ * already-taxed dollars. Planning-grade simplifications (annual coupons, no
+ * lot rounding) are documented in the ladder module.
+ */
+export declare const tipsLadderSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    purpose: z.ZodEnum<{
+        bridge: "bridge";
+        floor: "floor";
+    }>;
+    startYear: z.ZodNumber;
+    endYear: z.ZodNumber;
+    annualRealAmount: z.ZodNumber;
+    purchase: z.ZodOptional<z.ZodObject<{
+        year: z.ZodNumber;
+        fundingAccountId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TipsLadder = z.infer<typeof tipsLadderSchema>;
+/**
+ * Safety-first income floor (optional, additive): TIPS ladders whose cash
+ * flows live inside the ledger. Absent = no ladders, byte-identical results.
+ */
+export declare const incomeFloorSchema: z.ZodObject<{
+    ladders: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        purpose: z.ZodEnum<{
+            bridge: "bridge";
+            floor: "floor";
+        }>;
+        startYear: z.ZodNumber;
+        endYear: z.ZodNumber;
+        annualRealAmount: z.ZodNumber;
+        purchase: z.ZodOptional<z.ZodObject<{
+            year: z.ZodNumber;
+            fundingAccountId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type IncomeFloor = z.infer<typeof incomeFloorSchema>;
+export declare const yearEarningSchema: z.ZodObject<{
+    year: z.ZodNumber;
+    amount: z.ZodNumber;
+}, z.core.$strip>;
+export declare const wagesIncomeSchema: z.ZodObject<{
+    type: z.ZodLiteral<"wages">;
+    id: z.ZodString;
+    personId: z.ZodString;
+    annualGross: z.ZodNumber;
+    endAge: z.ZodNullable<z.ZodNumber>;
+    realGrowthPct: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * A former spouse who can unlock a benefit on someone else's record: a living
+ * ex-spouse (divorced-spousal) or a deceased former spouse (survivor). Their PIA
+ * is a simple user estimate, not an earnings import (spec §1.3).
+ */
+export declare const formerSpouseSchema: z.ZodObject<{
+    id: z.ZodString;
+    relationship: z.ZodEnum<{
+        divorced: "divorced";
+        deceased: "deceased";
+    }>;
+    dob: z.ZodString;
+    piaMonthly: z.ZodNumber;
+    marriageYears: z.ZodNumber;
+    remarriedAtAge: z.ZodNullable<z.ZodNumber>;
+    deceasedClaimAge: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        years: z.ZodNumber;
+        months: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type FormerSpouse = z.infer<typeof formerSpouseSchema>;
+export declare const socialSecurityIncomeSchema: z.ZodObject<{
+    type: z.ZodLiteral<"socialSecurity">;
+    id: z.ZodString;
+    personId: z.ZodString;
+    piaMonthly: z.ZodNullable<z.ZodNumber>;
+    earnings: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        year: z.ZodNumber;
+        amount: z.ZodNumber;
+    }, z.core.$strip>>>;
+    earningsProjection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        assumedAnnualEarnings: z.ZodNullable<z.ZodNumber>;
+        throughAge: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    coveredQuarters: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    formerSpouses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        relationship: z.ZodEnum<{
+            divorced: "divorced";
+            deceased: "deceased";
+        }>;
+        dob: z.ZodString;
+        piaMonthly: z.ZodNumber;
+        marriageYears: z.ZodNumber;
+        remarriedAtAge: z.ZodNullable<z.ZodNumber>;
+        deceasedClaimAge: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            years: z.ZodNumber;
+            months: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    disability: z.ZodOptional<z.ZodObject<{
+        onsetAge: z.ZodNumber;
+    }, z.core.$strip>>;
+    claimAge: z.ZodObject<{
+        years: z.ZodNumber;
+        months: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const recurringIncomeSchema: z.ZodObject<{
+    type: z.ZodLiteral<"recurring">;
+    id: z.ZodString;
+    label: z.ZodString;
+    annualAmount: z.ZodNumber;
+    startYear: z.ZodNullable<z.ZodNumber>;
+    endYear: z.ZodNullable<z.ZodNumber>;
+    inflationAdjusted: z.ZodBoolean;
+    taxTreatment: z.ZodEnum<{
+        none: "none";
+        ordinary: "ordinary";
+    }>;
+}, z.core.$strip>;
+export declare const oneTimeIncomeSchema: z.ZodObject<{
+    type: z.ZodLiteral<"oneTime">;
+    id: z.ZodString;
+    label: z.ZodString;
+    year: z.ZodNumber;
+    amount: z.ZodNumber;
+    taxTreatment: z.ZodEnum<{
+        none: "none";
+        ordinary: "ordinary";
+        capitalGain: "capitalGain";
+    }>;
+}, z.core.$strip>;
+export declare const incomeStreamSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"wages">;
+    id: z.ZodString;
+    personId: z.ZodString;
+    annualGross: z.ZodNumber;
+    endAge: z.ZodNullable<z.ZodNumber>;
+    realGrowthPct: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"socialSecurity">;
+    id: z.ZodString;
+    personId: z.ZodString;
+    piaMonthly: z.ZodNullable<z.ZodNumber>;
+    earnings: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        year: z.ZodNumber;
+        amount: z.ZodNumber;
+    }, z.core.$strip>>>;
+    earningsProjection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        assumedAnnualEarnings: z.ZodNullable<z.ZodNumber>;
+        throughAge: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    coveredQuarters: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    formerSpouses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        relationship: z.ZodEnum<{
+            divorced: "divorced";
+            deceased: "deceased";
+        }>;
+        dob: z.ZodString;
+        piaMonthly: z.ZodNumber;
+        marriageYears: z.ZodNumber;
+        remarriedAtAge: z.ZodNullable<z.ZodNumber>;
+        deceasedClaimAge: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            years: z.ZodNumber;
+            months: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    disability: z.ZodOptional<z.ZodObject<{
+        onsetAge: z.ZodNumber;
+    }, z.core.$strip>>;
+    claimAge: z.ZodObject<{
+        years: z.ZodNumber;
+        months: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"recurring">;
+    id: z.ZodString;
+    label: z.ZodString;
+    annualAmount: z.ZodNumber;
+    startYear: z.ZodNullable<z.ZodNumber>;
+    endYear: z.ZodNullable<z.ZodNumber>;
+    inflationAdjusted: z.ZodBoolean;
+    taxTreatment: z.ZodEnum<{
+        none: "none";
+        ordinary: "ordinary";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"oneTime">;
+    id: z.ZodString;
+    label: z.ZodString;
+    year: z.ZodNumber;
+    amount: z.ZodNumber;
+    taxTreatment: z.ZodEnum<{
+        none: "none";
+        ordinary: "ordinary";
+        capitalGain: "capitalGain";
+    }>;
+}, z.core.$strip>], "type">;
+export type IncomeStream = z.infer<typeof incomeStreamSchema>;
+export declare const expensePhaseSchema: z.ZodObject<{
+    fromAge: z.ZodNumber;
+    multiplier: z.ZodNumber;
+}, z.core.$strip>;
+export type ExpensePhase = z.infer<typeof expensePhaseSchema>;
+/**
+ * Flexibility of spending, layered from must-fund to opportunistic. Drives the
+ * required-floor vs target-lifestyle distinction that guardrails act on. Absent
+ * on a goal ⇒ 'target' (the migration default; preserves today's behavior).
+ */
+export declare const spendingClassificationSchema: z.ZodEnum<{
+    required: "required";
+    target: "target";
+    ideal: "ideal";
+    excess: "excess";
+}>;
+export type SpendingClassification = z.infer<typeof spendingClassificationSchema>;
+/**
+ * How a one-time goal may move under a guardrail policy. 'fixed' funds in its
+ * target year exactly (today's behavior); 'movable' funds in its target year
+ * when spending is not being cut, and is delayed up to `latestYear` while the
+ * guardrail is cutting; if still unaffordable at `latestYear` under a cut, the
+ * unfunded amount is reported as a layer shortfall. 'skippable' is the same but
+ * dropped entirely if it is still unaffordable at `latestYear`. Absent ⇒ 'fixed'.
+ */
+export declare const goalFlexibilitySchema: z.ZodEnum<{
+    fixed: "fixed";
+    movable: "movable";
+    skippable: "skippable";
+}>;
+export type GoalFlexibility = z.infer<typeof goalFlexibilitySchema>;
+export declare const oneTimeGoalSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    year: z.ZodNumber;
+    amount: z.ZodNumber;
+    classification: z.ZodOptional<z.ZodEnum<{
+        required: "required";
+        target: "target";
+        ideal: "ideal";
+        excess: "excess";
+    }>>;
+    flexibility: z.ZodOptional<z.ZodEnum<{
+        fixed: "fixed";
+        movable: "movable";
+        skippable: "skippable";
+    }>>;
+    earliestYear: z.ZodOptional<z.ZodNumber>;
+    latestYear: z.ZodOptional<z.ZodNumber>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    minFundingPct: z.ZodOptional<z.ZodNumber>;
+    allowPartialFunding: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OneTimeGoal = z.infer<typeof oneTimeGoalSchema>;
+export declare const healthcareConfigSchema: z.ZodObject<{
+    pre65MonthlyPremiumPerPerson: z.ZodNumber;
+    applyAcaCredit: z.ZodBoolean;
+    medicareExtrasMonthlyPerPerson: z.ZodNumber;
+    ssa44: z.ZodOptional<z.ZodObject<{
+        survivorYears: z.ZodBoolean;
+        retirementYears: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Opt-in spending policy layered over the fixed baseline (planning-depth roadmap
+ * §4). 'fixedTarget' (or absent) reproduces today's behavior: the whole spending
+ * stack is funded every year. 'withdrawalRateGuardrails' rations the
+ * discretionary layer (baseAnnual − requiredAnnual, plus flexible goals) path by
+ * path — cutting when the current withdrawal rate runs too far above the
+ * starting rate and restoring when it falls back — while always funding the
+ * required floor. 'riskBasedGuardrails' uses the same rationing machinery but
+ * triggers on the real portfolio balance against solver-derived dollar
+ * thresholds: the balance levels at which the plan's Monte Carlo probability of
+ * success would leave the user's target band (Kitces / risk-based guardrail
+ * methodology). The thresholds are solved on shared Monte Carlo paths
+ * (engine/montecarlo/riskBasedGuardrails.ts) and stored here as percentages of
+ * the starting portfolio; until they are solved the mode adjusts nothing.
+ * @see app/src/engine/spending/guardrails.ts
+ */
+/**
+ * Amortization-based withdrawal (ABW) parameters — the Bogleheads-formalized
+ * family that VPW, TPAW, and CAPE-based rules are members of. Each year the
+ * ledger recomputes the lifestyle spending target by amortizing the actual
+ * start-of-year investable balance over the remaining horizon at an expected
+ * real return, with an optional spending tilt (payments planned to grow at
+ * `tiltPct` real per year; negative = front-loaded, Blanchett-consistent).
+ * Only used when spendingPolicy.mode = 'abw'. @see engine/spending/abw.ts
+ */
+export declare const abwPolicySchema: z.ZodObject<{
+    returnSource: z.ZodEnum<{
+        fixed: "fixed";
+        cape: "cape";
+        tips: "tips";
+    }>;
+    fixedRealReturnPct: z.ZodOptional<z.ZodNumber>;
+    startingCape: z.ZodOptional<z.ZodNumber>;
+    equitySharePct: z.ZodOptional<z.ZodNumber>;
+    bondRealYieldPct: z.ZodOptional<z.ZodNumber>;
+    horizon: z.ZodOptional<z.ZodEnum<{
+        planningAge: "planningAge";
+        survival25: "survival25";
+        survival10: "survival10";
+    }>>;
+    tiltPct: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type AbwPolicy = z.infer<typeof abwPolicySchema>;
+export declare const spendingPolicySchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        fixedTarget: "fixedTarget";
+        withdrawalRateGuardrails: "withdrawalRateGuardrails";
+        riskBasedGuardrails: "riskBasedGuardrails";
+        abw: "abw";
+    }>;
+    abw: z.ZodOptional<z.ZodObject<{
+        returnSource: z.ZodEnum<{
+            fixed: "fixed";
+            cape: "cape";
+            tips: "tips";
+        }>;
+        fixedRealReturnPct: z.ZodOptional<z.ZodNumber>;
+        startingCape: z.ZodOptional<z.ZodNumber>;
+        equitySharePct: z.ZodOptional<z.ZodNumber>;
+        bondRealYieldPct: z.ZodOptional<z.ZodNumber>;
+        horizon: z.ZodOptional<z.ZodEnum<{
+            planningAge: "planningAge";
+            survival25: "survival25";
+            survival10: "survival10";
+        }>>;
+        tiltPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    upperGuardrailPct: z.ZodOptional<z.ZodNumber>;
+    lowerGuardrailPct: z.ZodOptional<z.ZodNumber>;
+    targetSuccessLowerPct: z.ZodOptional<z.ZodNumber>;
+    targetSuccessUpperPct: z.ZodOptional<z.ZodNumber>;
+    lowerBalanceThresholdPct: z.ZodOptional<z.ZodNumber>;
+    upperBalanceThresholdPct: z.ZodOptional<z.ZodNumber>;
+    adjustmentPct: z.ZodOptional<z.ZodNumber>;
+    allowRaisesAboveTarget: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SpendingPolicy = z.infer<typeof spendingPolicySchema>;
+export declare const expensePlanSchema: z.ZodObject<{
+    baseAnnual: z.ZodNumber;
+    requiredAnnual: z.ZodOptional<z.ZodNumber>;
+    idealAnnual: z.ZodOptional<z.ZodNumber>;
+    excessAnnual: z.ZodOptional<z.ZodNumber>;
+    phases: z.ZodArray<z.ZodObject<{
+        fromAge: z.ZodNumber;
+        multiplier: z.ZodNumber;
+    }, z.core.$strip>>;
+    oneTimeGoals: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        year: z.ZodNumber;
+        amount: z.ZodNumber;
+        classification: z.ZodOptional<z.ZodEnum<{
+            required: "required";
+            target: "target";
+            ideal: "ideal";
+            excess: "excess";
+        }>>;
+        flexibility: z.ZodOptional<z.ZodEnum<{
+            fixed: "fixed";
+            movable: "movable";
+            skippable: "skippable";
+        }>>;
+        earliestYear: z.ZodOptional<z.ZodNumber>;
+        latestYear: z.ZodOptional<z.ZodNumber>;
+        priority: z.ZodOptional<z.ZodNumber>;
+        minFundingPct: z.ZodOptional<z.ZodNumber>;
+        allowPartialFunding: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    healthcare: z.ZodObject<{
+        pre65MonthlyPremiumPerPerson: z.ZodNumber;
+        applyAcaCredit: z.ZodBoolean;
+        medicareExtrasMonthlyPerPerson: z.ZodNumber;
+        ssa44: z.ZodOptional<z.ZodObject<{
+            survivorYears: z.ZodBoolean;
+            retirementYears: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    spendingPolicy: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            fixedTarget: "fixedTarget";
+            withdrawalRateGuardrails: "withdrawalRateGuardrails";
+            riskBasedGuardrails: "riskBasedGuardrails";
+            abw: "abw";
+        }>;
+        abw: z.ZodOptional<z.ZodObject<{
+            returnSource: z.ZodEnum<{
+                fixed: "fixed";
+                cape: "cape";
+                tips: "tips";
+            }>;
+            fixedRealReturnPct: z.ZodOptional<z.ZodNumber>;
+            startingCape: z.ZodOptional<z.ZodNumber>;
+            equitySharePct: z.ZodOptional<z.ZodNumber>;
+            bondRealYieldPct: z.ZodOptional<z.ZodNumber>;
+            horizon: z.ZodOptional<z.ZodEnum<{
+                planningAge: "planningAge";
+                survival25: "survival25";
+                survival10: "survival10";
+            }>>;
+            tiltPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        upperGuardrailPct: z.ZodOptional<z.ZodNumber>;
+        lowerGuardrailPct: z.ZodOptional<z.ZodNumber>;
+        targetSuccessLowerPct: z.ZodOptional<z.ZodNumber>;
+        targetSuccessUpperPct: z.ZodOptional<z.ZodNumber>;
+        lowerBalanceThresholdPct: z.ZodOptional<z.ZodNumber>;
+        upperBalanceThresholdPct: z.ZodOptional<z.ZodNumber>;
+        adjustmentPct: z.ZodOptional<z.ZodNumber>;
+        allowRaisesAboveTarget: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    survivorSpendingPct: z.ZodOptional<z.ZodNumber>;
+    bequestTargetDollars: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ExpensePlan = z.infer<typeof expensePlanSchema>;
+export declare const rothConversionStrategySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"none">;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"manual">;
+    conversions: z.ZodArray<z.ZodObject<{
+        year: z.ZodNumber;
+        amount: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"optimized">;
+    conversions: z.ZodArray<z.ZodObject<{
+        year: z.ZodNumber;
+        amount: z.ZodNumber;
+    }, z.core.$strip>>;
+    optimizedAtIso: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"fillToTarget">;
+    target: z.ZodEnum<{
+        topOfBracket: "topOfBracket";
+        irmaaTier: "irmaaTier";
+        acaCliff: "acaCliff";
+        fixedMagi: "fixedMagi";
+    }>;
+    targetValue: z.ZodNullable<z.ZodNumber>;
+    startYear: z.ZodNumber;
+    endYear: z.ZodNumber;
+}, z.core.$strip>], "mode">;
+export declare const withdrawalStrategySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"sequential">;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"proportional">;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"bracketTargeted">;
+    bracketPct: z.ZodNumber;
+}, z.core.$strip>], "mode">;
+/**
+ * Itemized-deduction components in today's dollars (roadmap V8). Optional — when
+ * present, federal tax uses the greater of the standard deduction and this total
+ * (SALT capped by the pack). SALT is the user's own estimate of deductible
+ * state/local/property tax, kept separate from the engine's computed state tax.
+ */
+export declare const itemizedDeductionsSchema: z.ZodObject<{
+    stateAndLocalTaxes: z.ZodNumber;
+    mortgageInterest: z.ZodNumber;
+    charitable: z.ZodNumber;
+}, z.core.$strip>;
+export type ItemizedDeductions = z.infer<typeof itemizedDeductionsSchema>;
+export declare const strategiesSchema: z.ZodObject<{
+    withdrawalOrder: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"sequential">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"proportional">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"bracketTargeted">;
+        bracketPct: z.ZodNumber;
+    }, z.core.$strip>], "mode">;
+    rothConversion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"none">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"manual">;
+        conversions: z.ZodArray<z.ZodObject<{
+            year: z.ZodNumber;
+            amount: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"optimized">;
+        conversions: z.ZodArray<z.ZodObject<{
+            year: z.ZodNumber;
+            amount: z.ZodNumber;
+        }, z.core.$strip>>;
+        optimizedAtIso: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"fillToTarget">;
+        target: z.ZodEnum<{
+            topOfBracket: "topOfBracket";
+            irmaaTier: "irmaaTier";
+            acaCliff: "acaCliff";
+            fixedMagi: "fixedMagi";
+        }>;
+        targetValue: z.ZodNullable<z.ZodNumber>;
+        startYear: z.ZodNumber;
+        endYear: z.ZodNumber;
+    }, z.core.$strip>], "mode">;
+    qcdAnnual: z.ZodNumber;
+    itemizedDeductions: z.ZodOptional<z.ZodObject<{
+        stateAndLocalTaxes: z.ZodNumber;
+        mortgageInterest: z.ZodNumber;
+        charitable: z.ZodNumber;
+    }, z.core.$strip>>;
+    taxableSafetyNetFloor: z.ZodOptional<z.ZodNumber>;
+    survivorReserveTarget: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type Strategies = z.infer<typeof strategiesSchema>;
+export declare const assumptionsSchema: z.ZodObject<{
+    inflationPct: z.ZodNumber;
+    healthcareExtraInflationPct: z.ZodNumber;
+    defaultReturnPct: z.ZodNumber;
+    ssCola: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"matchInflation">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"fixed">;
+        annualPct: z.ZodNumber;
+    }, z.core.$strip>], "mode">;
+    ssHaircut: z.ZodNullable<z.ZodObject<{
+        fromYear: z.ZodNumber;
+        cutPct: z.ZodNumber;
+    }, z.core.$strip>>;
+    stateEffectiveTaxPct: z.ZodNumber;
+    localIncomeTaxPct: z.ZodDefault<z.ZodNumber>;
+    recentAnnualMagi: z.ZodNumber;
+    heirTaxRatePct: z.ZodDefault<z.ZodNumber>;
+    heirTaxByClass: z.ZodOptional<z.ZodObject<{
+        traditional: z.ZodOptional<z.ZodNumber>;
+        hsa: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    safeWithdrawalRatePct: z.ZodDefault<z.ZodNumber>;
+    assetClassParams: z.ZodOptional<z.ZodObject<{
+        usStocks: z.ZodOptional<z.ZodObject<{
+            returnPct: z.ZodOptional<z.ZodNumber>;
+            volatilityPct: z.ZodOptional<z.ZodNumber>;
+            interestYieldPct: z.ZodOptional<z.ZodNumber>;
+            dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+            qualifiedRatioPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        intlStocks: z.ZodOptional<z.ZodObject<{
+            returnPct: z.ZodOptional<z.ZodNumber>;
+            volatilityPct: z.ZodOptional<z.ZodNumber>;
+            interestYieldPct: z.ZodOptional<z.ZodNumber>;
+            dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+            qualifiedRatioPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        bonds: z.ZodOptional<z.ZodObject<{
+            returnPct: z.ZodOptional<z.ZodNumber>;
+            volatilityPct: z.ZodOptional<z.ZodNumber>;
+            interestYieldPct: z.ZodOptional<z.ZodNumber>;
+            dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+            qualifiedRatioPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        cash: z.ZodOptional<z.ZodObject<{
+            returnPct: z.ZodOptional<z.ZodNumber>;
+            volatilityPct: z.ZodOptional<z.ZodNumber>;
+            interestYieldPct: z.ZodOptional<z.ZodNumber>;
+            dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+            qualifiedRatioPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Assumptions = z.infer<typeof assumptionsSchema>;
+export declare const scenarioSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type Scenario = z.infer<typeof scenarioSchema>;
+export declare const planOriginSchema: z.ZodDefault<z.ZodEnum<{
+    user: "user";
+    example: "example";
+}>>;
+export type PlanOrigin = z.infer<typeof planOriginSchema>;
+export declare const planSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    name: z.ZodString;
+    origin: z.ZodDefault<z.ZodEnum<{
+        user: "user";
+        example: "example";
+    }>>;
+    exampleSourceId: z.ZodOptional<z.ZodString>;
+    createdAtIso: z.ZodString;
+    updatedAtIso: z.ZodString;
+    household: z.ZodObject<{
+        filingStatus: z.ZodEnum<{
+            single: "single";
+            marriedFilingJointly: "marriedFilingJointly";
+        }>;
+        hasQualifyingDependent: z.ZodDefault<z.ZodBoolean>;
+        state: z.ZodString;
+        stateMoves: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            fromYear: z.ZodNumber;
+            fromMonth: z.ZodDefault<z.ZodNumber>;
+            state: z.ZodString;
+        }, z.core.$strip>>>;
+        capitalLossCarryforward: z.ZodDefault<z.ZodNumber>;
+        people: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            dob: z.ZodString;
+            sex: z.ZodEnum<{
+                female: "female";
+                male: "male";
+                average: "average";
+            }>;
+            retirementAge: z.ZodNullable<z.ZodNumber>;
+            longevity: z.ZodObject<{
+                planningAge: z.ZodNumber;
+                source: z.ZodEnum<{
+                    model: "model";
+                    manual: "manual";
+                    percentile: "percentile";
+                }>;
+                percentile: z.ZodOptional<z.ZodObject<{
+                    pct: z.ZodNumber;
+                    joint: z.ZodBoolean;
+                    healthMultiplier: z.ZodOptional<z.ZodNumber>;
+                    partnerHealthMultiplier: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    accounts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"taxable">;
+        balance: z.ZodNumber;
+        costBasis: z.ZodNumber;
+        interestYieldPct: z.ZodOptional<z.ZodNumber>;
+        dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+        qualifiedRatio: z.ZodOptional<z.ZodNumber>;
+        reinvestDividends: z.ZodOptional<z.ZodBoolean>;
+        allocation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"static">;
+        }, z.core.$strip>, z.ZodObject<{
+            from: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            to: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            startYear: z.ZodNumber;
+            endYear: z.ZodNumber;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"linear">;
+        }, z.core.$strip>, z.ZodObject<{
+            stages: z.ZodArray<z.ZodObject<{
+                fromYear: z.ZodNumber;
+                weights: z.ZodObject<{
+                    usStocks: z.ZodDefault<z.ZodNumber>;
+                    intlStocks: z.ZodDefault<z.ZodNumber>;
+                    bonds: z.ZodDefault<z.ZodNumber>;
+                    cash: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"staged">;
+        }, z.core.$strip>, z.ZodObject<{
+            targets: z.ZodArray<z.ZodObject<{
+                year: z.ZodNumber;
+                weights: z.ZodObject<{
+                    usStocks: z.ZodDefault<z.ZodNumber>;
+                    intlStocks: z.ZodDefault<z.ZodNumber>;
+                    bonds: z.ZodDefault<z.ZodNumber>;
+                    cash: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"custom">;
+        }, z.core.$strip>], "mode">>;
+        annualContribution: z.ZodNumber;
+        contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            annualAmount: z.ZodNumber;
+            fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            escalationPct: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        ownerPersonId: z.ZodNullable<z.ZodString>;
+        annualReturnPct: z.ZodNullable<z.ZodNumber>;
+        estateBeneficiary: z.ZodOptional<z.ZodObject<{
+            destination: z.ZodEnum<{
+                spouse: "spouse";
+                nonSpouse: "nonSpouse";
+                charity: "charity";
+            }>;
+            charityPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"equityComp">;
+        balance: z.ZodNumber;
+        costBasis: z.ZodNumber;
+        annualContribution: z.ZodNumber;
+        contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            annualAmount: z.ZodNumber;
+            fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            escalationPct: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        vestingMode: z.ZodEnum<{
+            final: "final";
+            cliff: "cliff";
+        }>;
+        vestDate: z.ZodNullable<z.ZodString>;
+        id: z.ZodString;
+        name: z.ZodString;
+        ownerPersonId: z.ZodNullable<z.ZodString>;
+        annualReturnPct: z.ZodNullable<z.ZodNumber>;
+        estateBeneficiary: z.ZodOptional<z.ZodObject<{
+            destination: z.ZodEnum<{
+                spouse: "spouse";
+                nonSpouse: "nonSpouse";
+                charity: "charity";
+            }>;
+            charityPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"traditional">;
+        kind: z.ZodEnum<{
+            ira: "ira";
+            employer: "employer";
+        }>;
+        balance: z.ZodNumber;
+        annualContribution: z.ZodNumber;
+        inherited: z.ZodOptional<z.ZodObject<{
+            ownerDeathYear: z.ZodNumber;
+            decedentHadStartedRmds: z.ZodBoolean;
+        }, z.core.$strip>>;
+        nondeductibleBasis: z.ZodOptional<z.ZodNumber>;
+        spouseSoleBeneficiary: z.ZodOptional<z.ZodBoolean>;
+        sepp: z.ZodOptional<z.ZodObject<{
+            startAge: z.ZodNumber;
+            method: z.ZodEnum<{
+                rmd: "rmd";
+                amortization: "amortization";
+            }>;
+        }, z.core.$strip>>;
+        employerMatch: z.ZodOptional<z.ZodObject<{
+            matchPct: z.ZodNumber;
+            capPctOfPay: z.ZodNumber;
+        }, z.core.$strip>>;
+        contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            annualAmount: z.ZodNumber;
+            fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            escalationPct: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        allocation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"static">;
+        }, z.core.$strip>, z.ZodObject<{
+            from: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            to: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            startYear: z.ZodNumber;
+            endYear: z.ZodNumber;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"linear">;
+        }, z.core.$strip>, z.ZodObject<{
+            stages: z.ZodArray<z.ZodObject<{
+                fromYear: z.ZodNumber;
+                weights: z.ZodObject<{
+                    usStocks: z.ZodDefault<z.ZodNumber>;
+                    intlStocks: z.ZodDefault<z.ZodNumber>;
+                    bonds: z.ZodDefault<z.ZodNumber>;
+                    cash: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"staged">;
+        }, z.core.$strip>, z.ZodObject<{
+            targets: z.ZodArray<z.ZodObject<{
+                year: z.ZodNumber;
+                weights: z.ZodObject<{
+                    usStocks: z.ZodDefault<z.ZodNumber>;
+                    intlStocks: z.ZodDefault<z.ZodNumber>;
+                    bonds: z.ZodDefault<z.ZodNumber>;
+                    cash: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"custom">;
+        }, z.core.$strip>], "mode">>;
+        id: z.ZodString;
+        name: z.ZodString;
+        ownerPersonId: z.ZodNullable<z.ZodString>;
+        annualReturnPct: z.ZodNullable<z.ZodNumber>;
+        estateBeneficiary: z.ZodOptional<z.ZodObject<{
+            destination: z.ZodEnum<{
+                spouse: "spouse";
+                nonSpouse: "nonSpouse";
+                charity: "charity";
+            }>;
+            charityPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"roth">;
+        kind: z.ZodEnum<{
+            ira: "ira";
+            employer: "employer";
+        }>;
+        balance: z.ZodNumber;
+        annualContribution: z.ZodNumber;
+        contributionBasis: z.ZodOptional<z.ZodNumber>;
+        employerMatch: z.ZodOptional<z.ZodObject<{
+            matchPct: z.ZodNumber;
+            capPctOfPay: z.ZodNumber;
+        }, z.core.$strip>>;
+        contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            annualAmount: z.ZodNumber;
+            fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            escalationPct: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        allocation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"static">;
+        }, z.core.$strip>, z.ZodObject<{
+            from: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            to: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            startYear: z.ZodNumber;
+            endYear: z.ZodNumber;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"linear">;
+        }, z.core.$strip>, z.ZodObject<{
+            stages: z.ZodArray<z.ZodObject<{
+                fromYear: z.ZodNumber;
+                weights: z.ZodObject<{
+                    usStocks: z.ZodDefault<z.ZodNumber>;
+                    intlStocks: z.ZodDefault<z.ZodNumber>;
+                    bonds: z.ZodDefault<z.ZodNumber>;
+                    cash: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"staged">;
+        }, z.core.$strip>, z.ZodObject<{
+            targets: z.ZodArray<z.ZodObject<{
+                year: z.ZodNumber;
+                weights: z.ZodObject<{
+                    usStocks: z.ZodDefault<z.ZodNumber>;
+                    intlStocks: z.ZodDefault<z.ZodNumber>;
+                    bonds: z.ZodDefault<z.ZodNumber>;
+                    cash: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"custom">;
+        }, z.core.$strip>], "mode">>;
+        id: z.ZodString;
+        name: z.ZodString;
+        ownerPersonId: z.ZodNullable<z.ZodString>;
+        annualReturnPct: z.ZodNullable<z.ZodNumber>;
+        estateBeneficiary: z.ZodOptional<z.ZodObject<{
+            destination: z.ZodEnum<{
+                spouse: "spouse";
+                nonSpouse: "nonSpouse";
+                charity: "charity";
+            }>;
+            charityPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"hsa">;
+        balance: z.ZodNumber;
+        annualContribution: z.ZodNumber;
+        contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            annualAmount: z.ZodNumber;
+            fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            escalationPct: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        withdrawalTreatment: z.ZodOptional<z.ZodEnum<{
+            assumeAllQualified: "assumeAllQualified";
+            capByMedicalExpenses: "capByMedicalExpenses";
+        }>>;
+        reimburseLater: z.ZodOptional<z.ZodBoolean>;
+        beneficiary: z.ZodOptional<z.ZodEnum<{
+            spouse: "spouse";
+            nonSpouse: "nonSpouse";
+        }>>;
+        allocation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            weights: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"static">;
+        }, z.core.$strip>, z.ZodObject<{
+            from: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            to: z.ZodObject<{
+                usStocks: z.ZodDefault<z.ZodNumber>;
+                intlStocks: z.ZodDefault<z.ZodNumber>;
+                bonds: z.ZodDefault<z.ZodNumber>;
+                cash: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            startYear: z.ZodNumber;
+            endYear: z.ZodNumber;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"linear">;
+        }, z.core.$strip>, z.ZodObject<{
+            stages: z.ZodArray<z.ZodObject<{
+                fromYear: z.ZodNumber;
+                weights: z.ZodObject<{
+                    usStocks: z.ZodDefault<z.ZodNumber>;
+                    intlStocks: z.ZodDefault<z.ZodNumber>;
+                    bonds: z.ZodDefault<z.ZodNumber>;
+                    cash: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"staged">;
+        }, z.core.$strip>, z.ZodObject<{
+            targets: z.ZodArray<z.ZodObject<{
+                year: z.ZodNumber;
+                weights: z.ZodObject<{
+                    usStocks: z.ZodDefault<z.ZodNumber>;
+                    intlStocks: z.ZodDefault<z.ZodNumber>;
+                    bonds: z.ZodDefault<z.ZodNumber>;
+                    cash: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            rebalancing: z.ZodDefault<z.ZodEnum<{
+                annual: "annual";
+                none: "none";
+            }>>;
+            mode: z.ZodLiteral<"custom">;
+        }, z.core.$strip>], "mode">>;
+        id: z.ZodString;
+        name: z.ZodString;
+        ownerPersonId: z.ZodNullable<z.ZodString>;
+        annualReturnPct: z.ZodNullable<z.ZodNumber>;
+        estateBeneficiary: z.ZodOptional<z.ZodObject<{
+            destination: z.ZodEnum<{
+                spouse: "spouse";
+                nonSpouse: "nonSpouse";
+                charity: "charity";
+            }>;
+            charityPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"cash">;
+        balance: z.ZodNumber;
+        annualContribution: z.ZodNumber;
+        contributionSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            annualAmount: z.ZodNumber;
+            fromAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            toAge: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            escalationPct: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        ownerPersonId: z.ZodNullable<z.ZodString>;
+        annualReturnPct: z.ZodNullable<z.ZodNumber>;
+        estateBeneficiary: z.ZodOptional<z.ZodObject<{
+            destination: z.ZodEnum<{
+                spouse: "spouse";
+                nonSpouse: "nonSpouse";
+                charity: "charity";
+            }>;
+            charityPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"pension">;
+        source: z.ZodOptional<z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>>;
+        startAge: z.ZodNumber;
+        monthlyAmount: z.ZodNumber;
+        colaPct: z.ZodNumber;
+        survivorPct: z.ZodNumber;
+        lumpSumOffer: z.ZodOptional<z.ZodObject<{
+            amount: z.ZodNumber;
+            electionYear: z.ZodNumber;
+        }, z.core.$strip>>;
+        lumpSumElection: z.ZodOptional<z.ZodObject<{
+            rolloverAccountId: z.ZodString;
+        }, z.core.$strip>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        ownerPersonId: z.ZodNullable<z.ZodString>;
+        annualReturnPct: z.ZodNullable<z.ZodNumber>;
+        estateBeneficiary: z.ZodOptional<z.ZodObject<{
+            destination: z.ZodEnum<{
+                spouse: "spouse";
+                nonSpouse: "nonSpouse";
+                charity: "charity";
+            }>;
+            charityPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"annuity">;
+        startAge: z.ZodNumber;
+        monthlyAmount: z.ZodNumber;
+        colaPct: z.ZodNumber;
+        taxablePct: z.ZodNumber;
+        purchase: z.ZodOptional<z.ZodObject<{
+            year: z.ZodNumber;
+            premium: z.ZodNumber;
+            fundingAccountId: z.ZodString;
+            taxQualification: z.ZodEnum<{
+                nonQualified: "nonQualified";
+                qualified: "qualified";
+            }>;
+            qlac: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        payoutForm: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"lifeOnly">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"periodCertain">;
+            certainYears: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"jointSurvivor">;
+            survivorPct: z.ZodNumber;
+        }, z.core.$strip>], "kind">>;
+        id: z.ZodString;
+        name: z.ZodString;
+        ownerPersonId: z.ZodNullable<z.ZodString>;
+        annualReturnPct: z.ZodNullable<z.ZodNumber>;
+        estateBeneficiary: z.ZodOptional<z.ZodObject<{
+            destination: z.ZodEnum<{
+                spouse: "spouse";
+                nonSpouse: "nonSpouse";
+                charity: "charity";
+            }>;
+            charityPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"property">;
+        value: z.ZodNumber;
+        plannedSaleYear: z.ZodNullable<z.ZodNumber>;
+        expectedNetProceeds: z.ZodNullable<z.ZodNumber>;
+        costBasis: z.ZodOptional<z.ZodNumber>;
+        sellingCostPct: z.ZodOptional<z.ZodNumber>;
+        primaryResidence: z.ZodOptional<z.ZodBoolean>;
+        depreciationRecapture: z.ZodOptional<z.ZodNumber>;
+        propertyTaxAnnual: z.ZodOptional<z.ZodNumber>;
+        insuranceAnnual: z.ZodOptional<z.ZodNumber>;
+        hecm: z.ZodOptional<z.ZodObject<{
+            openYear: z.ZodNumber;
+            principalLimitPct: z.ZodOptional<z.ZodNumber>;
+            growthRatePct: z.ZodNumber;
+            upfrontCostPct: z.ZodOptional<z.ZodNumber>;
+            drawPolicy: z.ZodEnum<{
+                coordinated: "coordinated";
+                lastResort: "lastResort";
+            }>;
+        }, z.core.$strip>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        ownerPersonId: z.ZodNullable<z.ZodString>;
+        annualReturnPct: z.ZodNullable<z.ZodNumber>;
+        estateBeneficiary: z.ZodOptional<z.ZodObject<{
+            destination: z.ZodEnum<{
+                spouse: "spouse";
+                nonSpouse: "nonSpouse";
+                charity: "charity";
+            }>;
+            charityPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"debt">;
+        balance: z.ZodNumber;
+        interestPct: z.ZodNumber;
+        monthlyPayment: z.ZodNumber;
+        payoffYear: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        id: z.ZodString;
+        name: z.ZodString;
+        ownerPersonId: z.ZodNullable<z.ZodString>;
+        annualReturnPct: z.ZodNullable<z.ZodNumber>;
+        estateBeneficiary: z.ZodOptional<z.ZodObject<{
+            destination: z.ZodEnum<{
+                spouse: "spouse";
+                nonSpouse: "nonSpouse";
+                charity: "charity";
+            }>;
+            charityPct: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "type">>;
+    insurance: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"ltc">;
+        id: z.ZodString;
+        name: z.ZodString;
+        owner: z.ZodString;
+        annualPremium: z.ZodNumber;
+        premiumMode: z.ZodEnum<{
+            lifetime: "lifetime";
+            paidUp: "paidUp";
+            untilAge: "untilAge";
+        }>;
+        premiumEndAge: z.ZodOptional<z.ZodNumber>;
+        benefitMonthly: z.ZodNumber;
+        benefitPeriodYears: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"lifetime">]>;
+        eliminationPeriodDays: z.ZodNumber;
+        inflationRiderPct: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"permanentLife">;
+        id: z.ZodString;
+        name: z.ZodString;
+        insured: z.ZodString;
+        beneficiary: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"estate">]>;
+        annualPremium: z.ZodNumber;
+        premiumMode: z.ZodEnum<{
+            lifetime: "lifetime";
+            paidUp: "paidUp";
+            untilAge: "untilAge";
+        }>;
+        premiumEndAge: z.ZodOptional<z.ZodNumber>;
+        deathBenefit: z.ZodNumber;
+        cashValue: z.ZodNumber;
+        cashValueMode: z.ZodEnum<{
+            flatRate: "flatRate";
+            schedule: "schedule";
+        }>;
+        cashValueGrowthPct: z.ZodOptional<z.ZodNumber>;
+        cashValueSchedule: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            age: z.ZodNumber;
+            value: z.ZodNumber;
+        }, z.core.$strip>>>;
+        dividendOption: z.ZodOptional<z.ZodEnum<{
+            cash: "cash";
+            reducePremium: "reducePremium";
+            paidUpAdditions: "paidUpAdditions";
+        }>>;
+    }, z.core.$strip>], "kind">>>;
+    careEvents: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        personId: z.ZodString;
+        startAge: z.ZodNumber;
+        durationYears: z.ZodNumber;
+        annualCost: z.ZodNumber;
+    }, z.core.$strip>>>;
+    incomes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"wages">;
+        id: z.ZodString;
+        personId: z.ZodString;
+        annualGross: z.ZodNumber;
+        endAge: z.ZodNullable<z.ZodNumber>;
+        realGrowthPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"socialSecurity">;
+        id: z.ZodString;
+        personId: z.ZodString;
+        piaMonthly: z.ZodNullable<z.ZodNumber>;
+        earnings: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            year: z.ZodNumber;
+            amount: z.ZodNumber;
+        }, z.core.$strip>>>;
+        earningsProjection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            assumedAnnualEarnings: z.ZodNullable<z.ZodNumber>;
+            throughAge: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        coveredQuarters: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        formerSpouses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            relationship: z.ZodEnum<{
+                divorced: "divorced";
+                deceased: "deceased";
+            }>;
+            dob: z.ZodString;
+            piaMonthly: z.ZodNumber;
+            marriageYears: z.ZodNumber;
+            remarriedAtAge: z.ZodNullable<z.ZodNumber>;
+            deceasedClaimAge: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                years: z.ZodNumber;
+                months: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        disability: z.ZodOptional<z.ZodObject<{
+            onsetAge: z.ZodNumber;
+        }, z.core.$strip>>;
+        claimAge: z.ZodObject<{
+            years: z.ZodNumber;
+            months: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"recurring">;
+        id: z.ZodString;
+        label: z.ZodString;
+        annualAmount: z.ZodNumber;
+        startYear: z.ZodNullable<z.ZodNumber>;
+        endYear: z.ZodNullable<z.ZodNumber>;
+        inflationAdjusted: z.ZodBoolean;
+        taxTreatment: z.ZodEnum<{
+            none: "none";
+            ordinary: "ordinary";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"oneTime">;
+        id: z.ZodString;
+        label: z.ZodString;
+        year: z.ZodNumber;
+        amount: z.ZodNumber;
+        taxTreatment: z.ZodEnum<{
+            none: "none";
+            ordinary: "ordinary";
+            capitalGain: "capitalGain";
+        }>;
+    }, z.core.$strip>], "type">>;
+    incomeFloor: z.ZodOptional<z.ZodObject<{
+        ladders: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            purpose: z.ZodEnum<{
+                bridge: "bridge";
+                floor: "floor";
+            }>;
+            startYear: z.ZodNumber;
+            endYear: z.ZodNumber;
+            annualRealAmount: z.ZodNumber;
+            purchase: z.ZodOptional<z.ZodObject<{
+                year: z.ZodNumber;
+                fundingAccountId: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    expenses: z.ZodObject<{
+        baseAnnual: z.ZodNumber;
+        requiredAnnual: z.ZodOptional<z.ZodNumber>;
+        idealAnnual: z.ZodOptional<z.ZodNumber>;
+        excessAnnual: z.ZodOptional<z.ZodNumber>;
+        phases: z.ZodArray<z.ZodObject<{
+            fromAge: z.ZodNumber;
+            multiplier: z.ZodNumber;
+        }, z.core.$strip>>;
+        oneTimeGoals: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            year: z.ZodNumber;
+            amount: z.ZodNumber;
+            classification: z.ZodOptional<z.ZodEnum<{
+                required: "required";
+                target: "target";
+                ideal: "ideal";
+                excess: "excess";
+            }>>;
+            flexibility: z.ZodOptional<z.ZodEnum<{
+                fixed: "fixed";
+                movable: "movable";
+                skippable: "skippable";
+            }>>;
+            earliestYear: z.ZodOptional<z.ZodNumber>;
+            latestYear: z.ZodOptional<z.ZodNumber>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            minFundingPct: z.ZodOptional<z.ZodNumber>;
+            allowPartialFunding: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        healthcare: z.ZodObject<{
+            pre65MonthlyPremiumPerPerson: z.ZodNumber;
+            applyAcaCredit: z.ZodBoolean;
+            medicareExtrasMonthlyPerPerson: z.ZodNumber;
+            ssa44: z.ZodOptional<z.ZodObject<{
+                survivorYears: z.ZodBoolean;
+                retirementYears: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        spendingPolicy: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                fixedTarget: "fixedTarget";
+                withdrawalRateGuardrails: "withdrawalRateGuardrails";
+                riskBasedGuardrails: "riskBasedGuardrails";
+                abw: "abw";
+            }>;
+            abw: z.ZodOptional<z.ZodObject<{
+                returnSource: z.ZodEnum<{
+                    fixed: "fixed";
+                    cape: "cape";
+                    tips: "tips";
+                }>;
+                fixedRealReturnPct: z.ZodOptional<z.ZodNumber>;
+                startingCape: z.ZodOptional<z.ZodNumber>;
+                equitySharePct: z.ZodOptional<z.ZodNumber>;
+                bondRealYieldPct: z.ZodOptional<z.ZodNumber>;
+                horizon: z.ZodOptional<z.ZodEnum<{
+                    planningAge: "planningAge";
+                    survival25: "survival25";
+                    survival10: "survival10";
+                }>>;
+                tiltPct: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            upperGuardrailPct: z.ZodOptional<z.ZodNumber>;
+            lowerGuardrailPct: z.ZodOptional<z.ZodNumber>;
+            targetSuccessLowerPct: z.ZodOptional<z.ZodNumber>;
+            targetSuccessUpperPct: z.ZodOptional<z.ZodNumber>;
+            lowerBalanceThresholdPct: z.ZodOptional<z.ZodNumber>;
+            upperBalanceThresholdPct: z.ZodOptional<z.ZodNumber>;
+            adjustmentPct: z.ZodOptional<z.ZodNumber>;
+            allowRaisesAboveTarget: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        survivorSpendingPct: z.ZodOptional<z.ZodNumber>;
+        bequestTargetDollars: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    strategies: z.ZodObject<{
+        withdrawalOrder: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"sequential">;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"proportional">;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"bracketTargeted">;
+            bracketPct: z.ZodNumber;
+        }, z.core.$strip>], "mode">;
+        rothConversion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"none">;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"manual">;
+            conversions: z.ZodArray<z.ZodObject<{
+                year: z.ZodNumber;
+                amount: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"optimized">;
+            conversions: z.ZodArray<z.ZodObject<{
+                year: z.ZodNumber;
+                amount: z.ZodNumber;
+            }, z.core.$strip>>;
+            optimizedAtIso: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"fillToTarget">;
+            target: z.ZodEnum<{
+                topOfBracket: "topOfBracket";
+                irmaaTier: "irmaaTier";
+                acaCliff: "acaCliff";
+                fixedMagi: "fixedMagi";
+            }>;
+            targetValue: z.ZodNullable<z.ZodNumber>;
+            startYear: z.ZodNumber;
+            endYear: z.ZodNumber;
+        }, z.core.$strip>], "mode">;
+        qcdAnnual: z.ZodNumber;
+        itemizedDeductions: z.ZodOptional<z.ZodObject<{
+            stateAndLocalTaxes: z.ZodNumber;
+            mortgageInterest: z.ZodNumber;
+            charitable: z.ZodNumber;
+        }, z.core.$strip>>;
+        taxableSafetyNetFloor: z.ZodOptional<z.ZodNumber>;
+        survivorReserveTarget: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    assumptions: z.ZodObject<{
+        inflationPct: z.ZodNumber;
+        healthcareExtraInflationPct: z.ZodNumber;
+        defaultReturnPct: z.ZodNumber;
+        ssCola: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"matchInflation">;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"fixed">;
+            annualPct: z.ZodNumber;
+        }, z.core.$strip>], "mode">;
+        ssHaircut: z.ZodNullable<z.ZodObject<{
+            fromYear: z.ZodNumber;
+            cutPct: z.ZodNumber;
+        }, z.core.$strip>>;
+        stateEffectiveTaxPct: z.ZodNumber;
+        localIncomeTaxPct: z.ZodDefault<z.ZodNumber>;
+        recentAnnualMagi: z.ZodNumber;
+        heirTaxRatePct: z.ZodDefault<z.ZodNumber>;
+        heirTaxByClass: z.ZodOptional<z.ZodObject<{
+            traditional: z.ZodOptional<z.ZodNumber>;
+            hsa: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        safeWithdrawalRatePct: z.ZodDefault<z.ZodNumber>;
+        assetClassParams: z.ZodOptional<z.ZodObject<{
+            usStocks: z.ZodOptional<z.ZodObject<{
+                returnPct: z.ZodOptional<z.ZodNumber>;
+                volatilityPct: z.ZodOptional<z.ZodNumber>;
+                interestYieldPct: z.ZodOptional<z.ZodNumber>;
+                dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+                qualifiedRatioPct: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            intlStocks: z.ZodOptional<z.ZodObject<{
+                returnPct: z.ZodOptional<z.ZodNumber>;
+                volatilityPct: z.ZodOptional<z.ZodNumber>;
+                interestYieldPct: z.ZodOptional<z.ZodNumber>;
+                dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+                qualifiedRatioPct: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            bonds: z.ZodOptional<z.ZodObject<{
+                returnPct: z.ZodOptional<z.ZodNumber>;
+                volatilityPct: z.ZodOptional<z.ZodNumber>;
+                interestYieldPct: z.ZodOptional<z.ZodNumber>;
+                dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+                qualifiedRatioPct: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            cash: z.ZodOptional<z.ZodObject<{
+                returnPct: z.ZodOptional<z.ZodNumber>;
+                volatilityPct: z.ZodOptional<z.ZodNumber>;
+                interestYieldPct: z.ZodOptional<z.ZodNumber>;
+                dividendYieldPct: z.ZodOptional<z.ZodNumber>;
+                qualifiedRatioPct: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    scenarios: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Plan = z.infer<typeof planSchema>;
+export type ParsePlanResult = {
+    ok: true;
+    plan: Plan;
+} | {
+    ok: false;
+    issues: string[];
+};
+export declare function parsePlan(input: unknown): ParsePlanResult;
+export interface CreatePlanOptions {
+    newId?: () => string;
+    now?: () => Date;
+    name?: string;
+}
+export declare function createEmptyPlan(opts?: CreatePlanOptions): Plan;