@org-design-studio/core 0.1.0

package/dist-core/core.d.mts

@@ -0,0 +1,642 @@
+/**
+ * ORG DESIGN STUDIO — Core data model.
+ *
+ * All workforce data is processed client-side. The Employee record mirrors the
+ * upload template; optional fields degrade gracefully throughout analytics.
+ */
+/**
+ * Seat occupancy of a position record. Absent = "filled" — every record
+ * persisted or imported before this field existed represents a person in a
+ * seat. "vacant" = budgeted seat, currently unoccupied (open requisition);
+ * "tbh" = planned/to-be-hired seat (e.g. created in a scenario). For
+ * vacant/TBH seats, total_cost carries the BUDGETED cost of the seat.
+ */
+type PositionStatus = "filled" | "vacant" | "tbh";
+/**
+ * Resolve a record's seat status, guarding legacy/malformed data: anything
+ * other than an explicit "vacant"/"tbh" reads as "filled".
+ */
+declare function positionStatus(e: Pick<Employee, "position_status">): PositionStatus;
+interface Employee {
+    employee_id: string;
+    employee_name: string;
+    role_title: string;
+    manager_id: string | null;
+    manager_name?: string;
+    department: string;
+    function: string;
+    business_unit: string;
+    location: string;
+    country: string;
+    grade: string;
+    level: number;
+    employment_type: string;
+    fte: number;
+    salary: number;
+    bonus: number;
+    total_cost: number;
+    status: string;
+    /** Seat occupancy — absent = filled. Read via positionStatus(), never directly. */
+    position_status?: PositionStatus;
+    tenure?: number;
+    gender?: string;
+    age_band?: string;
+    performance_rating?: string;
+    potential_rating?: string;
+    critical_role?: boolean;
+    role_family?: string;
+    role_type?: string;
+    cost_center?: string;
+    legal_entity?: string;
+    contract_type?: string;
+    remote_status?: string;
+    skills?: string;
+    succession_risk?: string;
+    attrition_risk?: string;
+    change_impact?: string;
+    comments?: string;
+}
+/** Derived, computed per-employee attributes (never stored, always recomputed). */
+interface EmployeeNode {
+    employee: Employee;
+    layer: number;
+    directReports: string[];
+    span: number;
+    filledSpan: number;
+    downstreamHeadcount: number;
+    downstreamCost: number;
+    isManager: boolean;
+    isManagerOfOne: boolean;
+    managesOnlyManagers: boolean;
+    managerChain: string[];
+}
+interface OrgTree {
+    nodes: Map<string, EmployeeNode>;
+    roots: string[];
+    maxLayer: number;
+    orphans: string[];
+    circular: string[];
+}
+interface SpanTargetByLevel {
+    level: number;
+    label: string;
+    min: number;
+    max: number;
+}
+/**
+ * Transition / one-time cost model for restructuring scenarios.
+ * Used to net year-1 savings against the cost of executing the change.
+ */
+interface TransitionAssumptions {
+    severanceMonthsByLevel: {
+        maxLevel: number;
+        months: number;
+    }[];
+    backfillPct: number;
+    oneTimeChangeCostPerMove: number;
+    effectiveMonth: number;
+    countrySeveranceMultipliers: Record<string, number>;
+}
+/** Month labels for the transition effective-month control (1-indexed). */
+declare const MONTH_NAMES: readonly ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+/**
+ * Default seniority-noise tokens stripped from role titles before duplication
+ * grouping. Deliberately excludes "assistant" / "lead" / "associate" — those
+ * usually denote genuinely different jobs ("Assistant Manager" ≠ "Manager").
+ */
+declare const DEFAULT_TITLE_NOISE_WORDS: string[];
+interface Assumptions {
+    narrowSpanThreshold: number;
+    wideSpanThreshold: number;
+    targetSpansByLevel: SpanTargetByLevel[];
+    targetMaxLayers: number;
+    delayeringSavingPct: number;
+    duplicateRoleSavingPct: number;
+    spanOptPremiumPct: number;
+    locationCostMultipliers: Record<string, number>;
+    currency: string;
+    currencySymbol: string;
+    scoringWeights: ScenarioScoringWeights;
+    benchmarkLayersForSize: {
+        maxHeadcount: number;
+        layers: number;
+    }[];
+    transitionAssumptions: TransitionAssumptions;
+    aiAugmentationByRoleFamily: Record<string, "high" | "medium" | "low">;
+    titleNoiseWords: string[];
+    highCostThreshold: number;
+}
+interface ScenarioScoringWeights {
+    financialImpact: number;
+    spanImprovement: number;
+    layerReduction: number;
+    complexityReduction: number;
+    changeRisk: number;
+    implementationEase: number;
+}
+declare const DEFAULT_ASSUMPTIONS: Assumptions;
+type IssueSeverity = "critical" | "warning" | "info";
+interface DataQualityIssue {
+    id: string;
+    severity: IssueSeverity;
+    category: string;
+    message: string;
+    employeeIds: string[];
+}
+interface DataQualityReport {
+    score: number;
+    band: "Strong" | "Usable" | "Needs cleanup" | "Poor";
+    issues: DataQualityIssue[];
+    counts: {
+        critical: number;
+        warning: number;
+        info: number;
+    };
+}
+type ScenarioChange = {
+    type: "move";
+    employeeId: string;
+    newManagerId: string;
+    description: string;
+} | {
+    type: "remove_role";
+    employeeId: string;
+    reportsTo: "managers_manager" | "specific" | "orphan";
+    newManagerId?: string;
+    description: string;
+} | {
+    type: "add_role";
+    employee: Employee;
+    description: string;
+} | {
+    type: "merge_teams";
+    sourceManagerId: string;
+    targetManagerId: string;
+    description: string;
+} | {
+    type: "delayer";
+    layer: number;
+    scope: {
+        field: "function" | "business_unit" | "all";
+        value?: string;
+    };
+    description: string;
+} | {
+    type: "location_shift";
+    employeeIds: string[];
+    targetLocation: string;
+    costMultiplier: number;
+    description: string;
+} | {
+    type: "cost_change";
+    employeeId: string;
+    newTotalCost: number;
+    description: string;
+} | {
+    type: "fill_role";
+    employeeId: string;
+    employeeName: string;
+    description: string;
+};
+interface ChangeLogEntry {
+    id: string;
+    timestamp: string;
+    change: ScenarioChange;
+    affectedCount: number;
+    costBefore: number;
+    costAfter: number;
+    headcountBefore: number;
+    headcountAfter: number;
+    layersBefore: number;
+    layersAfter: number;
+}
+interface Scenario {
+    id: string;
+    name: string;
+    description: string;
+    owner: string;
+    createdAt: string;
+    changes: ScenarioChange[];
+    changeLog: ChangeLogEntry[];
+    commentary: string;
+}
+interface SpanBucket {
+    label: string;
+    min: number;
+    max: number;
+    count: number;
+    managerIds: string[];
+}
+interface LayerStat {
+    layer: number;
+    headcount: number;
+    managers: number;
+    ics: number;
+    cost: number;
+    managementCost: number;
+    avgSpan: number;
+    medianSpan: number;
+    unfilledSeats: number;
+}
+interface OrgMetrics {
+    headcount: number;
+    totalFte: number;
+    totalCost: number;
+    filledHeadcount: number;
+    vacantSeats: number;
+    tbhSeats: number;
+    unfilledSeats: number;
+    vacancyRate: number;
+    runRateCost: number;
+    unfilledSeatCost: number;
+    avgFilledSpan: number;
+    medianFilledSpan: number;
+    unfilledByFunction: Record<string, number>;
+    unfilledByLayer: Record<number, number>;
+    managerCount: number;
+    icCount: number;
+    managerRatio: number;
+    managementCost: number;
+    icCost: number;
+    managementCostRatio: number;
+    maxLayers: number;
+    avgSpan: number;
+    medianSpan: number;
+    narrowSpanManagers: string[];
+    wideSpanManagers: string[];
+    narrowSpanPct: number;
+    wideSpanPct: number;
+    narrowSpanCost: number;
+    spanBuckets: SpanBucket[];
+    layerStats: LayerStat[];
+    costByFunction: Record<string, number>;
+    headcountByFunction: Record<string, number>;
+    layersByFunction: Record<string, number>;
+    avgSpanByFunction: Record<string, number>;
+    costByBU: Record<string, number>;
+    headcountByBU: Record<string, number>;
+    layersByBU: Record<string, number>;
+    costByLocation: Record<string, number>;
+    headcountByLocation: Record<string, number>;
+    costByGrade: Record<string, number>;
+    headcountByGrade: Record<string, number>;
+    costByLayer: Record<number, number>;
+    managementCostByLayer: Record<number, number>;
+    layerTaxPerIC: number;
+    managerOfOneCount: number;
+    managerOfManagersCount: number;
+    pureSupervisoryLayers: number[];
+    aiExposure: {
+        band: "high" | "medium" | "low";
+        headcount: number;
+        cost: number;
+    }[];
+    duplicateRoles: DuplicateRoleGroup[];
+    duplicateRoleCost: number;
+    deepestChains: {
+        ids: string[];
+        depth: number;
+    }[];
+    delayeringOpportunity: number;
+    spanOptimizationOpportunity: number;
+    duplicationOpportunity: number;
+    totalOpportunity: number;
+    orgHealth: OrgHealthScore;
+}
+interface DuplicateRoleGroup {
+    normalizedTitle: string;
+    employees: {
+        id: string;
+        name: string;
+        title: string;
+        unit: string;
+        cost: number;
+    }[];
+    units: string[];
+    totalCost: number;
+    /** Distinct raw titles that normalized into this group — lets the UI show the normalization. */
+    normalizedFrom: string[];
+}
+interface OrgHealthScore {
+    total: number;
+    components: {
+        name: string;
+        score: number;
+        weight: number;
+        explanation: string;
+    }[];
+}
+type InsightCategory = "structure" | "cost" | "span" | "layer" | "duplication" | "location" | "grade" | "risk" | "scenario" | "executive";
+interface Insight {
+    id: string;
+    title: string;
+    severity: "high" | "medium" | "low";
+    category: InsightCategory;
+    evidence: string;
+    impact: string;
+    recommendation: string;
+    relatedEntities: string[];
+    financialImpact: number;
+    employeesAffected: number;
+    confidence: "high" | "medium" | "low";
+    easeOfAction: "easy" | "moderate" | "hard";
+    linkTo: string;
+    rank?: number;
+}
+interface ChangeRisk {
+    level: "Low" | "Medium" | "High" | "Very High";
+    score: number;
+    factors: {
+        name: string;
+        value: number | string;
+        contribution: number;
+    }[];
+    recommendation: string;
+}
+interface ScenarioScore {
+    total: number;
+    categories: {
+        name: string;
+        score: number;
+        weight: number;
+    }[];
+}
+interface ScenarioEvaluation {
+    scenarioId: string;
+    metrics: OrgMetrics;
+    risk: ChangeRisk;
+    score: ScenarioScore;
+    costDelta: number;
+    headcountDelta: number;
+    layerDelta: number;
+    employeesMoved: number;
+    rolesRemoved: number;
+    rolesAdded: number;
+    transitionCost: number;
+    netYear1Saving: number;
+    runRateSaving: number;
+    year1CapturePct: number;
+    vacantSeatsRemoved: number;
+    seatsFilled: number;
+}
+declare const REQUIRED_FIELDS: readonly ["employee_id", "employee_name", "role_title", "manager_id", "department", "function", "business_unit", "location", "country", "grade", "level", "employment_type", "fte", "salary", "bonus", "total_cost", "status"];
+declare const OPTIONAL_FIELDS: readonly ["manager_name", "position_status", "tenure", "gender", "age_band", "performance_rating", "potential_rating", "critical_role", "role_family", "role_type", "cost_center", "legal_entity", "contract_type", "remote_status", "skills", "succession_risk", "attrition_risk", "change_impact", "comments"];
+type FieldMapping = Record<string, string | null>;
+
+/**
+ * Hierarchy engine: builds the org tree from flat employee records,
+ * computes layers, spans, downstream rollups, and detects structural defects
+ * (cycles, orphans, multiple roots).
+ *
+ * All functions are pure — they never mutate the input employee array.
+ */
+
+declare function buildOrgTree(employees: Employee[]): OrgTree;
+/** All employee ids in the subtree rooted at `id` (including `id`). */
+declare function subtreeIds(tree: OrgTree, id: string): string[];
+/** Longest reporting chains (root → leaf), top N. */
+declare function deepestChains(tree: OrgTree, topN?: number): {
+    ids: string[];
+    depth: number;
+}[];
+/** Would moving `employeeId` under `newManagerId` create a cycle? */
+declare function wouldCreateCycle(tree: OrgTree, employeeId: string, newManagerId: string): boolean;
+
+/**
+ * Normalize a role title for duplication grouping. Noise words default to
+ * DEFAULT_TITLE_NOISE_WORDS (seniority markers + roman/arabic numerals) and are
+ * configurable via assumptions.titleNoiseWords. Words like "assistant", "lead"
+ * and "associate" are deliberately NOT noise by default — they usually denote
+ * genuinely different jobs.
+ */
+declare function normalizeTitle(title: string, noiseWords?: string[]): string;
+/**
+ * Resolve the applicable target span band for an employee level from
+ * assumptions.targetSpansByLevel (assumed sorted by level ascending). Picks the
+ * entry with the largest level <= the employee level; if the level is below the
+ * first entry's level, the first entry is used. Returns undefined if there are
+ * no bands configured.
+ */
+declare function spanBandForLevel(level: number, assumptions: Assumptions): SpanTargetByLevel | undefined;
+/**
+ * Level-aware narrow/wide classification for a single manager span.
+ * When the employee level is 0/blank, falls back to the flat thresholds.
+ */
+declare function classifySpan(span: number, level: number, assumptions: Assumptions): {
+    narrow: boolean;
+    wide: boolean;
+};
+/**
+ * Classify a role's AI-augmentation potential. Uses an explicit role_family
+ * mapping when available; otherwise falls back to a conservative title-keyword
+ * heuristic. Augmentation potential is NOT a judgement on elimination.
+ */
+declare function classifyAiAugmentation(employee: Employee, assumptions: Assumptions): "high" | "medium" | "low";
+/**
+ * Potential duplicate leadership/specialist roles: same normalized title held
+ * in 2+ different business units (or 3+ holders in one unit) among the senior
+ * population. Seniority = explicit level 1–4; employees with no level data
+ * (level 0/blank) use a cost-percentile fallback — only the top 25% of
+ * total_cost within the dataset counts as senior, so unleveled populations are
+ * never flagged wholesale. Flagged as "potential duplication requiring
+ * review" — never auto-judged bad.
+ */
+declare function findDuplicateRoles(employees: Employee[], assumptions?: Assumptions): DuplicateRoleGroup[];
+declare function computeMetrics(employees: Employee[], assumptions: Assumptions): OrgMetrics;
+interface HealthInputs {
+    maxLayers: number;
+    headcount: number;
+    narrowPct: number;
+    widePct: number;
+    managerRatio: number;
+    mgmtCostRatio: number;
+    duplicateCost: number;
+    totalCost: number;
+}
+declare function computeOrgHealth(inp: HealthInputs, assumptions: Assumptions): OrgHealthScore;
+
+declare function validateEmployees(employees: Employee[]): DataQualityReport;
+/**
+ * Normalize a raw position-status cell to a PositionStatus. Recognizes common
+ * HRIS spellings case-/punctuation-insensitively; unknown values return
+ * undefined so callers can fall back to other signals (the safe default for
+ * anything unrecognized is "filled").
+ */
+declare function normalizePositionStatus(v: unknown): PositionStatus | undefined;
+declare function rowsToEmployees(rows: Record<string, unknown>[], mapping: Record<string, string | null>): Employee[];
+/**
+ * Auto-map uploaded column names to canonical fields by fuzzy name match.
+ *
+ * `extraAliases` (e.g. from an HRIS import template) are merged with the
+ * built-in ALIASES using the same normalization; where both could match,
+ * the extra aliases take precedence — exact extra match, then exact
+ * built-in, then fuzzy extra, then fuzzy built-in.
+ */
+declare function autoMapColumns(columns: string[], fields: readonly string[], extraAliases?: Record<string, string[]>): Record<string, string | null>;
+
+interface ApplyResult {
+    employees: Employee[];
+    warnings: string[];
+}
+/** Replay a change list onto the baseline. Pure — returns a new array. */
+declare function applyChanges(baseline: Employee[], changes: ScenarioChange[]): ApplyResult;
+/** Employees whose manager changed or who were removed/added vs baseline. */
+declare function diffEmployees(baseline: Employee[], scenario: Employee[]): {
+    moved: Employee[];
+    removed: Employee[];
+    added: Employee[];
+    costChanged: Employee[];
+    locationChanged: Employee[];
+    seatsFilled: Employee[];
+};
+declare function computeChangeRisk(baseline: Employee[], scenarioEmployees: Employee[], baselineMetrics: OrgMetrics, scenarioMetrics: OrgMetrics): ChangeRisk;
+/**
+ * Share (0–1) of the run-rate saving captured in year 1, derived from the
+ * month the changes take effect: (12 − effectiveMonth + 1)/12. Month 1 →
+ * full-year capture; month 12 → 1/12. Guards stale persisted assumptions
+ * (missing/out-of-range months fall back to the default).
+ */
+declare function year1CapturePct(assumptions: Assumptions): number;
+/**
+ * One-time + ramp cost of executing a scenario, computed additively:
+ *  - severance: monthly cost (total_cost/12) × severance months, per removed role
+ *    (severance months are scaled by the employee country's severance multiplier)
+ *  - backfill drag: backfillPct% of removed-role cost (annualized hiring/ramp)
+ *  - change cost: oneTimeChangeCostPerMove × employees moved
+ *  - location shifts: treated conservatively as exit-and-rehire — severance on
+ *    the BASELINE cost + backfillPct% of baseline cost (hiring/ramp in the new
+ *    location) + oneTimeChangeCostPerMove, per location-changed employee
+ *  - cost changes without a location change: oneTimeChangeCostPerMove only
+ *  - seat fills: backfillPct% of the seat's budgeted cost (hiring/ramp drag)
+ *
+ * Position-vs-person: vacant/TBH seats have nobody in them, so changes to
+ * unfilled seats move budget, not people — eliminating, moving or re-locating
+ * an unfilled seat incurs NO severance, backfill or per-move cost.
+ */
+declare function computeTransitionCost(baseline: Employee[], scenarioEmployees: Employee[], assumptions: Assumptions): number;
+declare function scoreScenario(baselineMetrics: OrgMetrics, scenarioMetrics: OrgMetrics, risk: ChangeRisk, assumptions: Assumptions, changeCount: number, netYear1Saving?: number, affectedEmployees?: number): ScenarioScore;
+declare function evaluateScenario(baseline: Employee[], scenario: Scenario, baselineMetrics: OrgMetrics, assumptions: Assumptions): ScenarioEvaluation;
+interface SuggestedAction {
+    change: ScenarioChange;
+    rationale: string;
+    estimatedSaving: number;
+}
+/** Rule-based consolidation suggestions: merge narrow-span managers into peers. */
+declare function suggestConsolidations(employees: Employee[], assumptions: Assumptions, scopeFunction?: string): SuggestedAction[];
+
+interface InsightContext {
+    employees: Employee[];
+    metrics: OrgMetrics;
+    assumptions: Assumptions;
+    scenarioEvaluations?: {
+        name: string;
+        evaluation: ScenarioEvaluation;
+    }[];
+}
+declare function generateInsights(ctx: InsightContext): Insight[];
+/** Rank: severity, then financial impact, then employees affected, confidence, ease. */
+declare function rankInsights(insights: Insight[]): Insight[];
+/** Convenience: compute everything from raw employees. */
+declare function generateInsightsFromEmployees(employees: Employee[], assumptions: Assumptions, scenarioEvaluations?: {
+    name: string;
+    evaluation: ScenarioEvaluation;
+}[]): Insight[];
+
+interface LayoutDatum {
+    id: string;
+    node: EmployeeNode;
+    collapsed: boolean;
+    children?: LayoutDatum[];
+}
+interface PositionedNode {
+    id: string;
+    x: number;
+    y: number;
+    node: EmployeeNode;
+    collapsed: boolean;
+}
+interface PositionedEdge {
+    id: string;
+    /** Elbow path string in canvas coordinates. */
+    path: string;
+    sourceId: string;
+    targetId: string;
+}
+interface CanvasLayout {
+    nodes: PositionedNode[];
+    edges: PositionedEdge[];
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    visibleCount: number;
+}
+interface LayoutOptions {
+    nodeWidth: number;
+    nodeHeight: number;
+    gapX: number;
+    gapY: number;
+}
+declare const FULL_NODE: LayoutOptions;
+declare const COMPACT_NODE: LayoutOptions;
+/** Run tidy-tree layout; returns positioned nodes/edges in canvas coords. */
+declare function layoutOrg(orgTree: OrgTree, rootIds: string[], isExpanded: (id: string) => boolean, opts: LayoutOptions): CanvasLayout;
+/** Orthogonal elbow: parent bottom-center → child top-center, rounded corners. */
+declare function elbowPath(x1: number, y1: number, x2: number, y2: number): string;
+/** Viewport transform helpers (pan/zoom math, kept pure for tests). */
+interface Viewport {
+    x: number;
+    y: number;
+    k: number;
+}
+declare function fitToBounds(bounds: CanvasLayout["bounds"], containerW: number, containerH: number, padding?: number, maxK?: number, minK?: number): Viewport;
+/** Zoom around a screen point (cursor), clamped. */
+declare function zoomAround(vp: Viewport, screenX: number, screenY: number, factor: number, minK?: number, maxK?: number): Viewport;
+/** Nodes intersecting the visible canvas region (viewport culling). */
+declare function visibleNodes(nodes: PositionedNode[], vp: Viewport, containerW: number, containerH: number, opts: LayoutOptions, overscan?: number): PositionedNode[];
+
+/**
+ * Demo dataset: "Meridian Global Services" — a fictional ~300-person company.
+ *
+ * Deterministic (seeded PRNG) so every load produces the same organization.
+ * The structure deliberately contains consulting-style findings:
+ *  - Technology is over-layered (8 layers) with a deep infrastructure chain
+ *  - Several narrow-span managers (1–2 reports), esp. in Finance & Technology
+ *  - Two overloaded managers (14–16 reports) in Customer Service & Operations
+ *  - Duplicate senior roles across business units (Heads of PMO, Ops Excellence)
+ *  - Expensive senior ICs reporting directly to executives
+ *  - Inconsistent role-title spellings
+ *  - One employee with an invalid manager reference, one zero-cost row
+ */
+
+declare function generateDemoData(): Employee[];
+
+/**
+ * Built-in HRIS import templates: column-name aliases + export instructions
+ * for the most common HR systems. Selecting a template on the upload page
+ * seeds `autoMapColumns` with each system's standard report/export field
+ * names so a raw export maps onto the canonical model with little manual work.
+ *
+ * Aliases are matched with the same normalization as autoMapColumns
+ * (lowercase, alphanumerics only), so spelling variants like "Reports To"
+ * vs "ReportsTo" need only one entry.
+ */
+interface HrisTemplate {
+    /** Stable identifier, e.g. "workday". */
+    id: string;
+    /** Display name, e.g. "Workday". */
+    name: string;
+    /** Canonical field -> column-name aliases as they appear in this system's exports. */
+    aliases: Record<string, string[]>;
+    /** Numbered steps an admin follows to pull the right report from the system. */
+    exportInstructions: string[];
+    /** Optional caveats about the system's export format. */
+    notes?: string;
+}
+declare const HRIS_TEMPLATES: HrisTemplate[];
+/** Look up a template by its stable id. */
+declare function getHrisTemplate(id: string): HrisTemplate | undefined;
+
+export { type ApplyResult, type Assumptions, COMPACT_NODE, type CanvasLayout, type ChangeLogEntry, type ChangeRisk, DEFAULT_ASSUMPTIONS, DEFAULT_TITLE_NOISE_WORDS, type DataQualityIssue, type DataQualityReport, type DuplicateRoleGroup, type Employee, type EmployeeNode, FULL_NODE, type FieldMapping, HRIS_TEMPLATES, type HrisTemplate, type Insight, type InsightCategory, type InsightContext, type IssueSeverity, type LayerStat, type LayoutDatum, type LayoutOptions, MONTH_NAMES, OPTIONAL_FIELDS, type OrgHealthScore, type OrgMetrics, type OrgTree, type PositionStatus, type PositionedEdge, type PositionedNode, REQUIRED_FIELDS, type Scenario, type ScenarioChange, type ScenarioEvaluation, type ScenarioScore, type ScenarioScoringWeights, type SpanBucket, type SpanTargetByLevel, type SuggestedAction, type TransitionAssumptions, type Viewport, applyChanges, autoMapColumns, buildOrgTree, classifyAiAugmentation, classifySpan, computeChangeRisk, computeMetrics, computeOrgHealth, computeTransitionCost, deepestChains, diffEmployees, elbowPath, evaluateScenario, findDuplicateRoles, fitToBounds, generateDemoData, generateInsights, generateInsightsFromEmployees, getHrisTemplate, layoutOrg, normalizePositionStatus, normalizeTitle, positionStatus, rankInsights, rowsToEmployees, scoreScenario, spanBandForLevel, subtreeIds, suggestConsolidations, validateEmployees, visibleNodes, wouldCreateCycle, year1CapturePct, zoomAround };