@seatlayer/core 0.53.0 → 0.55.0

package/dist/core/chart-ops/index.d.ts

@@ -0,0 +1,1235 @@
+import { a as SeatViewMetadata, d as SectionObject, ai as ZoneDef, C as ChartDoc, P as Point, r as CubicPath, x as Category, l as CategoryTier, z as ChartTheme, R as RowObject, X as ReferenceScanProposal, B as BoothObject, G as GAAreaObject, q as ShapeObject, T as TableObject, s as TextObject, ae as TextBackground, A as AccessibilityType, S as SeatOverride, c as ChartObject } from '../../types-DTSG6_Hq.js';
+import { e as CategoryInventoryObjectType } from '../../categoryInventory-BwarniiK.js';
+import { R as RelabelOptions } from '../../labeling-BmCzW50y.js';
+export { D as DEFAULT_SECTION_CORNER_SMOOTHING } from '../../labeling-BmCzW50y.js';
+
+type ChartObjectIdFactory = (prefix: string) => string;
+type AutomaticPlacement = 'auto' | 'front' | 'rear' | 'left' | 'right';
+declare class ChartOperationError extends Error {
+    readonly code: 'floor_not_found' | 'category_not_found' | 'category_in_use' | 'duplicate_category_label' | 'reference_category_protected' | 'object_not_found' | 'invalid_operation' | 'id_generation_failed';
+    readonly details: Record<string, unknown>;
+    constructor(code: 'floor_not_found' | 'category_not_found' | 'category_in_use' | 'duplicate_category_label' | 'reference_category_protected' | 'object_not_found' | 'invalid_operation' | 'id_generation_failed', message: string, details?: Record<string, unknown>);
+}
+/** Restore the canonical floor-zero mirror before persistence outside Designer. */
+interface LabelStylePatch {
+    size?: number | null;
+    color?: string | null;
+    visible?: boolean;
+}
+type SharedSectionMetadataPatch = {
+    label?: string;
+    displayLabel?: string | null;
+    /** Buyer-facing entrance hint (≤40 chars). null/empty clears it. */
+    entrance?: string | null;
+    /** Buyer view image inherited below seat/row overrides. null clears it. */
+    viewFromSeatUrl?: string | null;
+    /** Calibration and buyer disclosure paired with the section image. */
+    viewFromSeatMeta?: SeatViewMetadata | null;
+    labelPresentation?: SectionObject['labelPresentation'] | null;
+    /** Merge per-section label size/color/visibility (see LabelStylePatch). */
+    labelStyle?: LabelStylePatch;
+    zone?: string | null;
+    elevation?: number;
+    /** 3D-foundations front-edge height in metres (0–120). `null` clears it back to the elevation-tier fallback. */
+    height?: number | null;
+    /** 3D-foundations seating rake in degrees (0–45). `null` clears it back to 0 (flat). */
+    rake?: number | null;
+    /** Per-section 3D deck-surface correction (`flat` | `rakedRows`). `null`
+     * clears back to the shared scene compiler's automatic inference. */
+    surfaceKind?: SectionObject['surfaceKind'] | null;
+    color?: string | null;
+};
+interface SectionInventorySelectionSummary {
+    floorId: string;
+    sectionIds: string[];
+    logicalSectionIds: string[];
+    objectIds: string[];
+    /** Category can be painted only when every selected logical section owns inventory. */
+    categoryApplicable: boolean;
+    categoryKey?: string;
+    categoryMixed: boolean;
+    /** Section view inheritance is meaningful only when every logical section owns
+     * at least one row/table/booth seat that can open the buyer view. */
+    viewApplicable: boolean;
+}
+type SharedZonePatch = Partial<Pick<ZoneDef, 'label' | 'color' | 'focalPoint'>>;
+
+declare function mirrorFirstFloor(doc: ChartDoc): ChartDoc;
+declare const MAX_FLOOR_BASE_HEIGHT_M = 120;
+declare const DEFAULT_FLOOR_HEIGHT_STEP_M = 4;
+declare function addChartFloor(doc: ChartDoc, input: {
+    name?: string;
+    idFactory: ChartObjectIdFactory;
+}): {
+    changed: true;
+    floorId: string;
+    floorCount: number;
+    baseHeightM: number;
+};
+declare function renameChartFloor(doc: ChartDoc, input: {
+    floorId: string;
+    name: string;
+}): {
+    changed: boolean;
+    floorId: string;
+    floorName: string;
+};
+/** Update one persisted physical floor's absolute deck height. */
+declare function updateChartFloorBaseHeight(doc: ChartDoc, input: {
+    floorId: string;
+    baseHeightM: number;
+}): {
+    changed: boolean;
+    floorId: string;
+    baseHeightM: number;
+};
+declare function removeChartFloor(doc: ChartDoc, input: {
+    floorId: string;
+}): {
+    changed: true;
+    floorId: string;
+    removedObjects: number;
+    floorCount: number;
+};
+
+declare function addChartZone(doc: ChartDoc, input: {
+    label: string;
+    color: string;
+    focalPoint?: Point;
+    idFactory: ChartObjectIdFactory;
+}): {
+    changed: true;
+    zone: ZoneDef;
+};
+/** Rename or recolor stable zones atomically; section assignments are untouched. */
+declare function updateChartZones(doc: ChartDoc, input: {
+    updates: Array<{
+        zoneId: string;
+        patch: SharedZonePatch;
+    }>;
+}): {
+    changed: boolean;
+    zoneIds: string[];
+    zones: ZoneDef[];
+};
+/** Remove a stable zone; assigned sections require an explicit clearing opt-in. */
+declare function removeChartZone(doc: ChartDoc, input: {
+    zoneId: string;
+    clearSectionAssignments?: boolean;
+}): {
+    changed: true;
+    zoneId: string;
+    clearedSectionIds: string[];
+    zoneCount: number;
+};
+
+/**
+ * Inspect buyer inventory beneath a section selection without mutating it.
+ * Multipart components collapse to logical sections and membership comes from
+ * the same canonical resolver used by event inventory and the picker.
+ */
+declare function sectionInventorySelectionSummary(doc: ChartDoc, input: {
+    floorId?: string;
+    sectionIds: string[];
+}): SectionInventorySelectionSummary;
+/**
+ * Paint every buyer-bookable object owned by the selected logical sections.
+ * Seat/chair-level category exceptions are cleared (and only that key is
+ * cleared), so every current and subsequently unskipped seat inherits the new
+ * object category. Stable labels, ids, logical ids, geometry, and unrelated
+ * overrides remain byte-for-byte untouched.
+ */
+declare function assignSectionInventoryCategory(doc: ChartDoc, input: {
+    floorId?: string;
+    sectionIds: string[];
+    categoryKey: string;
+}): SectionInventorySelectionSummary & {
+    changed: boolean;
+    clearedSeatOverrideCount: number;
+};
+/** Update coordinate-free section metadata while preserving every outline and member position. */
+declare function updateSectionMetadata(doc: ChartDoc, input: {
+    floorId?: string;
+    sectionIds: string[];
+    patch: SharedSectionMetadataPatch;
+}): {
+    floorId: string;
+    changed: boolean;
+    sectionIds: string[];
+    affectedSectionIds: string[];
+};
+interface GeneratedSectionPolygonConversionPreview {
+    floorId: string;
+    sectionId: string;
+    sectionLabel: string;
+    source: {
+        representation: 'generated-polygon';
+        generator: NonNullable<SectionObject['geometry']>;
+    };
+    target: {
+        representation: 'manual-polygon';
+    };
+    geometryChanged: false;
+    preserved: {
+        stableId: true;
+        outlineVertexCount: number;
+        holeCount: number;
+        memberObjectIds: string[];
+        inventoryUnits: number;
+        durableReferenceSource: boolean;
+        inventoryExclusionEvidence: boolean;
+    };
+    removedFields: ['geometry'];
+}
+/**
+ * Describe the exact generated-polygon → manual-polygon conversion without
+ * mutating the chart. Exact path-backed sections are deliberately rejected:
+ * sampling a line/arc/Bézier path is a different, lossy conversion.
+ */
+declare function previewGeneratedSectionPolygonConversion(doc: ChartDoc, input: {
+    floorId?: string;
+    sectionId: string;
+}): GeneratedSectionPolygonConversionPreview;
+/** Remove generator provenance only; polygon, holes, ids and inventory stay byte-equivalent. */
+declare function convertGeneratedSectionToPolygon(doc: ChartDoc, input: {
+    floorId?: string;
+    sectionId: string;
+}): GeneratedSectionPolygonConversionPreview & {
+    changed: true;
+};
+type SectionBoundaryTransform = {
+    kind: 'translate';
+    dx: number;
+    dy: number;
+} | {
+    kind: 'scale';
+    factor: number;
+} | {
+    kind: 'rotate';
+    degrees: number;
+} | {
+    kind: 'reflect';
+    axis: 'h' | 'v';
+    coordinate: number;
+};
+interface SectionBoundaryTransformResult {
+    changed: boolean;
+    sectionId: string;
+    representation: 'exact-path' | 'polygon';
+    outlineVertexCount: number;
+    holeCount: number;
+    pathSegmentKinds: Array<'line' | 'arc' | 'bezier'>;
+}
+/**
+ * Transform every representation of one section boundary together. This is
+ * deliberately independent of React/Konva and does not infer or move section
+ * members; callers own membership policy, while this operation guarantees the
+ * outline, exact path and holes can never drift from one another.
+ */
+declare function transformSectionBoundaryObject(section: SectionObject, transform: SectionBoundaryTransform): SectionBoundaryTransformResult;
+/** Chart-scoped wrapper for server/shared-operation callers. */
+declare function transformSectionBoundary(doc: ChartDoc, input: {
+    floorId?: string;
+    sectionId: string;
+    transform: SectionBoundaryTransform;
+}): SectionBoundaryTransformResult & {
+    floorId: string;
+};
+/** Replace an exact section path atomically and regenerate only its deterministic
+ * polygon fallback. Stable identity, holes, inventory and durable reference
+ * links remain; obsolete hand-smoothing derivation state is discarded. */
+declare function updateSectionExactPath(doc: ChartDoc, input: {
+    floorId?: string;
+    sectionId: string;
+    path: NonNullable<SectionObject['outlinePath']>;
+}): {
+    floorId: string;
+    sectionId: string;
+    changed: boolean;
+    segmentKinds: Array<'line' | 'arc' | 'bezier'>;
+    sampledVertexCount: number;
+    holeCount: number;
+};
+/**
+ * Round the wide corners of hand-drawn polygon sections to a coordinate-free
+ * strength (0–100). The clicked polygon stays authoritative in `sourceOutline`;
+ * smoothing writes a curved `outlinePath` and re-samples `outline` from it, per
+ * the model contract. Strength 0 restores the exact clicked corners. This is the
+ * single shared implementation used by both the Designer slider and the MCP
+ * `update_sections` tool, so the two can never drift.
+ */
+declare function applySectionCornerSmoothing(doc: ChartDoc, input: {
+    floorId?: string;
+    sectionIds: string[];
+    strength: number;
+}): {
+    floorId: string;
+    changed: boolean;
+    sectionIds: string[];
+    affectedSectionIds: string[];
+};
+/**
+ * Shape a hand-drawn section's rendered outline from coordinate-free inputs:
+ * corner smoothing (0–100) and/or per-edge curvature (-100..100 per clicked
+ * edge). The clicked polygon stays authoritative in `sourceOutline`; shaping
+ * writes a curved `outlinePath` and re-samples `outline` from it. Clearing all
+ * shaping restores the exact clicked corners.
+ *
+ * Omitted inputs are LEFT AS THEY ARE, so setting curvature never silently
+ * discards a section's smoothing (or the reverse). Pass `null` to clear one.
+ */
+declare function applySectionOutlineShaping(doc: ChartDoc, input: {
+    floorId?: string;
+    sectionIds: string[];
+    cornerSmoothing?: number;
+    edgeCurvature?: readonly number[] | null;
+}): {
+    floorId: string;
+    changed: boolean;
+    sectionIds: string[];
+    affectedSectionIds: string[];
+};
+
+interface RowCubicPathPreview {
+    floorId: string;
+    rowId: string;
+    seatCount: number;
+    pathLength: number;
+    averageSeatMovement: number;
+    maxSeatMovement: number;
+    convertingFromParametric: boolean;
+    changed: boolean;
+    preservesStableId: true;
+    preservesSeatMetadata: true;
+    preservesInventoryUnits: number;
+}
+/** Validate and measure an exact cubic row centreline without changing identity,
+ * seat inventory, labels, categories, overrides, or reference source links. */
+declare function previewRowCubicPath(doc: ChartDoc, input: {
+    floorId?: string;
+    rowId: string;
+    path: CubicPath;
+}): RowCubicPathPreview;
+declare function updateRowCubicPath(doc: ChartDoc, input: {
+    floorId?: string;
+    rowId: string;
+    path: CubicPath;
+}): RowCubicPathPreview;
+interface SectionRowFitInput {
+    floorId?: string;
+    sectionId: string;
+    mode: 'focal' | 'outline';
+    /** Required only when a caller wants a focal other than the floor/chart focal point. */
+    focalPoint?: Point;
+    strength?: number;
+}
+interface SectionRowFitPreview {
+    floorId: string;
+    sectionId: string;
+    mode: 'focal' | 'outline';
+    fitCenter: Point;
+    strength: number;
+    rows: Array<{
+        rowId: string;
+        fromCurve: number;
+        targetCurve: number;
+        resultCurve: number;
+        fromRotation: number;
+        resultRotation: number;
+        rmsMovement: number;
+        maxMovement: number;
+    }>;
+    skippedPathRowIds: string[];
+    skippedInvalidRowIds: string[];
+    averageMovement: number;
+    maxMovement: number;
+}
+/** Preview a measured circular fit without changing rows or flattening paths. */
+declare function previewSectionRowFit(doc: ChartDoc, input: SectionRowFitInput): SectionRowFitPreview;
+/** Apply exactly the reviewed fit; stable row ids and seat metadata remain. */
+declare function applySectionRowFit(doc: ChartDoc, input: SectionRowFitInput): SectionRowFitPreview & {
+    changed: boolean;
+};
+interface PolygonHolePreview {
+    floorId: string;
+    objectId: string;
+    objectType: 'section' | 'gaArea';
+    holeIndex: number;
+    vertexCount: number;
+    excludedObjectIds: string[];
+    excludedInventoryUnits: number;
+    preservesExactOuterPath: boolean;
+}
+/** Validate and measure a new or replacement hole without mutating the chart. */
+declare function previewPolygonHole(doc: ChartDoc, input: {
+    floorId?: string;
+    objectId: string;
+    points: Point[];
+    holeIndex?: number;
+}): PolygonHolePreview;
+declare function applyPolygonHole(doc: ChartDoc, input: {
+    floorId?: string;
+    objectId: string;
+    points: Point[];
+    holeIndex?: number;
+}): PolygonHolePreview & {
+    changed: true;
+};
+declare function previewRemovePolygonHole(doc: ChartDoc, input: {
+    floorId?: string;
+    objectId: string;
+    holeIndex: number;
+}): PolygonHolePreview;
+declare function removePolygonHole(doc: ChartDoc, input: {
+    floorId?: string;
+    objectId: string;
+    holeIndex: number;
+}): PolygonHolePreview & {
+    changed: true;
+};
+
+type SharedCategoryPatch = Partial<Pick<Category, 'label' | 'color' | 'price' | 'notForSale'>> & {
+    tiers?: CategoryTier[] | null;
+};
+declare function updateCategoryDefinitions(doc: ChartDoc, input: {
+    updates: Array<{
+        categoryKey: string;
+        patch: SharedCategoryPatch;
+    }>;
+}): {
+    changed: boolean;
+    categoryKeys: string[];
+    categories: Category[];
+};
+/**
+ * Replace category document order without changing any stable category key or
+ * category payload. Document order is buyer-visible legend/filter priority and
+ * is also the deterministic input to colorblind-preview mapping, so it must be
+ * an explicit shared operation rather than an array splice hidden in Designer.
+ */
+declare function reorderChartCategories(doc: ChartDoc, input: {
+    categoryKeys: string[];
+}): {
+    changed: boolean;
+    categoryKeys: string[];
+    categories: Category[];
+};
+/** Okabe-Ito colorblind-safe hues (black dropped — unreadable on dark charts).
+ *  Single source of truth for the colorblind-safe palette. The author-time
+ *  preview, the new-category seed, the reassign op below, and SeatmapRenderer's
+ *  colorblind mode all key off THIS array by category document order, so a
+ *  reassigned chart reads identically with colorblind mode on or off. */
+declare const COLORBLIND_SAFE_PALETTE: readonly ["#e69f00", "#56b4e9", "#009e73", "#f0e442", "#0072b2", "#d55e00", "#cc79a7"];
+/**
+ * First Okabe-Ito hue that stays distinct from every color already in use, so
+ * the next category seeds a colorblind-safe hue. Falls back to indexing into the
+ * palette (then a rotated tint) when every safe hue is already taken, so a new
+ * category always gets *some* color. Callers may still override the color.
+ */
+declare function pickColorblindSafeCategoryColor(usedColors: string[], seedIndex: number, palette?: readonly string[]): string;
+interface ReassignColorblindSafeResult {
+    changed: Array<{
+        key: string;
+        from: string;
+        to: string;
+    }>;
+    categories: Category[];
+}
+/**
+ * Remap every category color onto a distinct Okabe-Ito colorblind-safe hue,
+ * assigned by category document order (the same order the author-time preview
+ * and SeatmapRenderer's colorblind mode key off). Colors only — labels, prices,
+ * tiers, keys and reference provenance are untouched. Deterministic: the same
+ * document in yields the same colors out. Returns the per-category before/after
+ * for every color that actually moved (empty when the palette is already
+ * applied). Mutates `doc.categories` in place (through the shared category-patch
+ * op, so the six-digit-hex/label/tier catalog invariants still hold).
+ */
+declare function reassignColorblindSafeCategoryColors(doc: ChartDoc, opts?: {
+    palette?: readonly string[];
+}): ReassignColorblindSafeResult;
+/**
+ * Record an organizer-confirmed screen/reference color without invalidating
+ * immutable source provenance. Non-reference categories simply receive the
+ * same validated color update.
+ */
+declare function confirmReferenceCategoryOutputColor(doc: ChartDoc, input: {
+    categoryKey: string;
+    color: string;
+    sourceDescription: string;
+}): {
+    changed: boolean;
+    category: Category;
+    categories: Category[];
+};
+declare function addChartCategory(doc: ChartDoc, input: {
+    label: string;
+    color: string;
+    price?: number;
+    tiers?: CategoryTier[];
+    idFactory: ChartObjectIdFactory;
+}): {
+    changed: true;
+    category: Category;
+    categories: Category[];
+};
+/** Plain-language derived name for a family sibling, e.g. “Standard – Tables”.
+ *  Any family suffix already on the base is stripped first so the words never
+ *  stack (“Standard – Tables” + booth → “Standard – Booths”). */
+declare function familyCategoryLabel(baseLabel: string, objectType: CategoryInventoryObjectType): string;
+interface ResolveCreationCategoryOptions {
+    idFactory: ChartObjectIdFactory;
+    palette?: readonly string[];
+    /** Fallback color chooser when every palette hue is already used. */
+    suggestColor?: (usedColors: string[]) => string;
+}
+/**
+ * Resolve the category a NEW object of `objectType` should be created with so
+ * the default authoring path never manufactures a category-inventory-family
+ * conflict (OV-76). A category prices exactly one inventory family, so drawing
+ * e.g. a table with the active row category — the two most obvious actions on a
+ * blank chart — would otherwise create a publish-blocking error. Resolution:
+ *   1. keep the active category when it stays within this family (the common
+ *      case: a blank chart's first object stays on “Standard”);
+ *   2. else, with NO active category, reuse the category this family is already
+ *      priced by. Without this step a blank chart's second table minted a
+ *      redundant “Tables – Tables” beside the “Tables” its first table had just
+ *      created, because a from-scratch doc starts with `categories: []` and the
+ *      designer's active key stays empty through that first mint;
+ *   3. else reuse an existing, still family-safe sibling with the derived name
+ *      (e.g. “Standard – Tables”) if one already exists;
+ *   4. else mint a sibling from the base category — same price and ticket tiers,
+ *      a plain “<Base> – Tables/Booths/Standing/Seats” name, and a distinct
+ *      colorblind-safe color so no contrast/CVD warning appears. With no active
+ *      category there is no author intent to inherit, so the mint is a plain
+ *      “Tables”/“Seats”/“Booths”/“Standing” rather than a name derived from
+ *      whichever unrelated category happens to sit first in the document.
+ * Mints are appended to `doc.categories` in place; the resolved key is returned.
+ * This covers CREATION defaults only — a later deliberate cross-family paint
+ * still surfaces the family error and its safe split.
+ */
+declare function resolveCreationCategory(doc: ChartDoc, activeCategoryKey: string, objectType: CategoryInventoryObjectType, options: ResolveCreationCategoryOptions): string;
+declare function removeChartCategory(doc: ChartDoc, input: {
+    categoryKey: string;
+}): {
+    changed: true;
+    categoryKey: string;
+    categories: Category[];
+};
+
+type SharedThemePatch = {
+    background?: string | null;
+    seatLabelColor?: string | null;
+    rowLabelColor?: string | null;
+    selectionColor?: string | null;
+    decorFill?: string | null;
+    textColor?: string | null;
+    accent?: string | null;
+    accentInk?: string | null;
+    fontFamily?: string | null;
+    seatScale?: number | null;
+    logoUrl?: string | null;
+    brandName?: string | null;
+    hideBadge?: boolean | null;
+};
+/**
+ * Merge chart-wide theme + white-label branding through the same field-level
+ * semantics as the Designer Theme tab. Colors run through the shared six-digit
+ * hex rule, seatScale is clamped to the renderer's 0.7–1.6 band, and logoUrl
+ * accepts only a data:image or https reference. `hideBadge` is stored verbatim;
+ * its paid-tier entitlement is enforced separately at buyer-serve time, exactly
+ * as a Designer toggle is (any organizer may set the stored flag).
+ */
+declare function updateChartTheme(doc: ChartDoc, input: {
+    patch: SharedThemePatch;
+}): {
+    changed: boolean;
+    theme: ChartTheme | null;
+};
+/**
+ * Set/clear the view-from-seat fallback at venue (chart) or floor scope — the
+ * two lowest-priority tiers below any seat/row/section photo. `floorId`
+ * undefined targets the venue default (`doc.viewFromSeatUrl`); a floor id sets
+ * that floor's override. `url` null clears the slot. Accepts only https or
+ * data:image references, exactly like section and seat view photos.
+ */
+declare function updateViewFromSeatFallback(doc: ChartDoc, input: {
+    floorId?: string;
+    url: string | null;
+    metadata?: SeatViewMetadata | null;
+}): {
+    changed: boolean;
+    scope: 'venue' | 'floor';
+    floorId?: string;
+    url: string | null;
+};
+/** Server-owned placement for coordinate-free callers. */
+declare function automaticPlacementCenter(doc: ChartDoc, input: {
+    floorId?: string;
+    width: number;
+    height: number;
+    placement?: AutomaticPlacement;
+}): Point;
+
+interface ArcFanRowsInput {
+    floorId?: string;
+    center: Point;
+    innerRadius: number;
+    rowCount: number;
+    rowGap: number;
+    startAngle: number;
+    endAngle: number;
+    seatPitch: number;
+    fit?: 'seat-pitch' | 'fixed-count';
+    seatsPerRow?: number;
+    facing?: 'inward' | 'outward';
+    /** Positive values narrow outer rows symmetrically, in degrees. */
+    taperDegrees?: number;
+    /** Clockwise bearing shift from the first row to the last, in degrees. */
+    skewDegrees?: number;
+    /** Physical aisle widths in chart units at quarter/centre/three-quarter span. */
+    aisleGaps?: Partial<Record<'left' | 'center' | 'right', number>>;
+    categoryKey: string;
+    rowLabelStart?: number;
+    seatLabelStart?: number;
+    sectionLabel?: string;
+}
+interface ArcFanRowsPreview {
+    floorId: string;
+    rows: RowObject[];
+    logicalRowCount: number;
+    rowSegmentCount: number;
+    totalSeats: number;
+    innerRadius: number;
+    outerRadius: number;
+    minSeatSpacing: number;
+    maxSeatSpacing: number;
+    maxPitchDeviation: number;
+    aisleCount: number;
+    warnings: string[];
+}
+/** Build a measured Arc/Fan preview without mutating the chart or consuming ids. */
+declare function previewArcFanRows(doc: ChartDoc, input: ArcFanRowsInput): ArcFanRowsPreview;
+/** Apply the exact measured preview as stable rows, optionally wrapped in a section. */
+declare function addArcFanRows(doc: ChartDoc, input: ArcFanRowsInput & {
+    idFactory: ChartObjectIdFactory;
+}): Omit<ArcFanRowsPreview, 'rows'> & {
+    rowIds: string[];
+    sectionId: string | null;
+    groupId: string;
+};
+/** Recover one coherent semantic specification for reopening a generated fan. */
+declare function arcFanInputForGroup(doc: ChartDoc, input: {
+    floorId?: string;
+    groupId: string;
+}): ArcFanRowsInput;
+/** Regenerate one coherent fan while preserving matching row and section ids. */
+declare function replaceArcFanRows(doc: ChartDoc, input: ArcFanRowsInput & {
+    groupId: string;
+    idFactory: ChartObjectIdFactory;
+}): Omit<ArcFanRowsPreview, 'rows'> & {
+    rowIds: string[];
+    sectionId: string | null;
+    groupId: string;
+};
+
+interface AddRowBlockInput {
+    floorId?: string;
+    origin: Point;
+    rowCount: number;
+    seatsPerRow: number;
+    categoryKey: string;
+    idFactory: ChartObjectIdFactory;
+    rowGap?: number;
+    seatSpacing?: number;
+    curve?: number;
+    /** Row direction in degrees (0 = seats run left→right). Applies to every row;
+     *  later rows stack along the normal so the whole block shares one rake. */
+    rotation?: number;
+    sectionLabel?: string;
+    /** Explicit block generator style. Absent preserves the legacy ungrouped output. */
+    style?: 'multiple' | 'intertwined';
+}
+declare function addRowBlock(doc: ChartDoc, input: AddRowBlockInput): {
+    floorId: string;
+    rowIds: string[];
+    sectionId: string | null;
+    createdIds: string[];
+};
+/** Footprint (width/height) for a GA rectangle of the given capacity. */
+declare function gaAreaFootprint(capacity: number): {
+    width: number;
+    height: number;
+};
+interface AddGAAreaInput {
+    floorId?: string;
+    /** Rectangle center in chart units — derived by the caller's placement policy. */
+    center: Point;
+    capacity: number;
+    categoryKey: string;
+    label?: string;
+    displayLabel?: string;
+    idFactory: ChartObjectIdFactory;
+}
+/**
+ * Add one rectangular GA standing area to an existing chart. The server owns
+ * the polygon: a rectangle sized from capacity at the catalog standing
+ * density, centered where the caller's placement policy chose. Additive and
+ * individually removable; nothing else on the chart moves.
+ */
+declare function addGAArea(doc: ChartDoc, input: AddGAAreaInput): {
+    floorId: string;
+    gaAreaId: string;
+    label: string;
+    createdIds: string[];
+};
+interface AddTableArrayInput {
+    floorId?: string;
+    /** Grid center in chart units — derived by the caller's placement policy. */
+    center: Point;
+    tableRows: number;
+    tableColumns: number;
+    seatsPerTable: number;
+    shape: 'round' | 'rect';
+    categoryKey: string;
+    idFactory: ChartObjectIdFactory;
+    gapX?: number;
+    gapY?: number;
+}
+/**
+ * Add a grid of identical tables to an existing chart, labelled `T{n}` from
+ * the first free number chart-wide. Geometry constants are the catalog table
+ * archetype's own (round radius 46, grid pitch 155×150), so an added banquet
+ * block matches a compiled one seat for seat.
+ */
+declare function addTableArray(doc: ChartDoc, input: AddTableArrayInput): {
+    floorId: string;
+    tableIds: string[];
+    createdIds: string[];
+};
+interface AddBoothArrayInput {
+    floorId?: string;
+    /** Grid center in chart units — derived by the caller's placement policy. */
+    center: Point;
+    boothRows: number;
+    boothColumns: number;
+    categoryKey: string;
+    idFactory: ChartObjectIdFactory;
+    gapX?: number;
+    gapY?: number;
+}
+/**
+ * Add a grid of booths to an existing chart, labelled `B{n}` from the first
+ * free number chart-wide. Booth footprint and pitch are the catalog expo
+ * archetype's constants (62×52 at 88×82).
+ */
+declare function addBoothArray(doc: ChartDoc, input: AddBoothArrayInput): {
+    floorId: string;
+    boothIds: string[];
+    createdIds: string[];
+};
+interface SegmentedRowGroupResult {
+    floorId: string;
+    groupId: string;
+    rowIds: string[];
+    changed: boolean;
+}
+/**
+ * Link existing physical rows into one buyer-facing segmented row without
+ * deleting/re-indexing any inventory. `boundaries[i]` describes the boundary
+ * before component i+1 and is mandatory so an aisle can never be inferred as
+ * continuous by accident.
+ */
+declare function groupRowsAsSegmented(doc: ChartDoc, input: {
+    floorId?: string;
+    rowIds: string[];
+    boundaries: Array<'continuous' | 'break'>;
+    displayLabel?: string;
+    idFactory: ChartObjectIdFactory;
+}): SegmentedRowGroupResult;
+/** Remove only logical grouping metadata; all physical row/seat bytes survive. */
+declare function ungroupSegmentedRow(doc: ChartDoc, input: {
+    floorId?: string;
+    groupId?: string;
+    rowId?: string;
+}): SegmentedRowGroupResult;
+/** Fan a safe logical-row presentation/boundary edit to every component. */
+declare function updateSegmentedRow(doc: ChartDoc, input: {
+    floorId?: string;
+    groupId: string;
+    displayLabel?: string;
+    boundaries?: Array<'continuous' | 'break'>;
+    smoothing?: boolean;
+    viewFromSeatUrl?: string | null;
+    viewFromSeatMeta?: SeatViewMetadata | null;
+}): SegmentedRowGroupResult;
+interface ReplaceRowBlockInput {
+    floorId?: string;
+    groupId: string;
+    style?: 'multiple' | 'intertwined';
+    rowCount?: number;
+    seatsPerRow?: number;
+    rowGap?: number;
+    seatSpacing?: number;
+    curve?: number;
+    rotation?: number;
+    origin?: Point;
+    idFactory: ChartObjectIdFactory;
+}
+interface ReplaceRowBlockResult {
+    floorId: string;
+    groupId: string;
+    rowIds: string[];
+    createdRowIds: string[];
+    removedRowIds: string[];
+    changed: boolean;
+}
+/**
+ * Reopen an intact multiple/intertwined generator and regenerate it while
+ * preserving every row id by row index and every surviving slot id. If any
+ * member lost provenance through a manual edit, the whole operation fails
+ * closed instead of overwriting that work.
+ */
+declare function replaceRowBlock(doc: ChartDoc, input: ReplaceRowBlockInput): ReplaceRowBlockResult;
+
+interface ReferenceScanRowsOptions {
+    floorId?: string;
+    /** Category assigned to every materialized row — bookables require one. */
+    categoryKey: string;
+    idFactory: ChartObjectIdFactory;
+}
+/** A targeted section left untouched because it still holds inventory the scan
+ *  may not overwrite (hand-authored, or from a different reference). */
+interface ReferenceScanSkippedSection {
+    sectionId: string;
+    name: string;
+    reason: 'section_not_empty';
+    objectIds: string[];
+}
+interface ReferenceScanSectionOutcome {
+    sectionId: string | null;
+    name: string;
+    seats: number;
+    rows: number;
+}
+interface ReferenceScanPreview {
+    totalSeats: number;
+    perSection: ReferenceScanSectionOutcome[];
+    skipped: ReferenceScanSkippedSection[];
+}
+interface ReferenceScanApplyResult extends ReferenceScanPreview {
+    floorId: string;
+    assetId: string;
+    createdRowIds: string[];
+    removedRowIds: string[];
+}
+declare function applyReferenceScanRows(doc: ChartDoc, proposal: ReferenceScanProposal, opts: ReferenceScanRowsOptions): ReferenceScanApplyResult;
+
+type SharedRowPatch = Partial<Omit<RowObject, 'type' | 'id' | 'arcFanGeneration' | 'segmentedRow' | 'rowBlockGeneration'>> & {
+    /**
+     * Coordinate-free label size/color/visibility merge directive. Applied on top
+     * of any `labelPresentation` in the same patch and, unlike a geometry edit,
+     * never invalidates a row's Arc/Fan generation provenance.
+     */
+    labelStyle?: LabelStylePatch;
+    /**
+     * Row-label end-position preset merge directive (start/end/both/none). Merges
+     * into `labelPresentation.positionPreset`, keeps `visible` coherent (none ⇒
+     * hidden), and clears any free-drag `position` so the label snaps back to an
+     * end. Pure presentation — never invalidates Arc/Fan provenance.
+     */
+    labelPosition?: 'start' | 'end' | 'both' | 'none';
+    /**
+     * Row-label rotation merge directive, degrees [-180,180], merged into
+     * `labelPresentation.rotation`. null resets it to 0. Pure presentation.
+     */
+    labelRotation?: number | null;
+    /**
+     * Row-label chrome style merge directive (plain text or a pill), merged into
+     * `labelPresentation.style`. Pure presentation.
+     */
+    labelStyleShape?: 'plain' | 'pill';
+};
+type SharedTablePatch = Partial<Pick<TableObject, 'label' | 'displayLabel' | 'displayType' | 'shape' | 'seatCount' | 'sides' | 'seatCountsBySide' | 'rotation' | 'radius' | 'seatArc' | 'width' | 'height' | 'categoryKey' | 'bookAsWhole' | 'variableOccupancy' | 'minOccupancy' | 'maxOccupancy'>>;
+type SharedBoothPatch = Partial<Pick<BoothObject, 'label' | 'displayLabel' | 'displayType' | 'width' | 'height' | 'rotation' | 'categoryKey'>> & {
+    /** Custom booth outline (closed polygon, local coordinates relative to the
+     * booth centre). `null` clears it, restoring the rectangle. */
+    points?: Point[] | null;
+};
+type SharedGAAreaPatch = Partial<Pick<GAAreaObject, 'label' | 'displayLabel' | 'displayType' | 'capacity' | 'categoryKey' | 'cornerRadius'>>;
+type SharedShapePatch = Partial<Pick<ShapeObject, 'kind'>> & {
+    label?: string | null;
+    fill?: string | null;
+    /** null clears the outline. `width` is clamped to 0.5–40 chart units. */
+    stroke?: {
+        color: string;
+        width: number;
+    } | null;
+    /** null clears rounding. Clamped to half the shape's short side (rect only). */
+    cornerRadius?: number | null;
+    /** Whole-shape opacity, clamped to 0.1–1. null resets to fully opaque. */
+    opacity?: number | null;
+    /** Physical 3D extrusion in metres. null restores the semantic-role default. */
+    heightM?: number | null;
+    /** Event layouts that include this structure. null makes it common to all. */
+    eventConfigurationIds?: string[] | null;
+    /** Open line/polyline only. null restores the legacy round cap. */
+    lineCap?: ShapeObject['lineCap'] | null;
+    /** Open line/polyline only. null restores the legacy round join. */
+    lineJoin?: ShapeObject['lineJoin'] | null;
+    /** Open line/polyline only. null restores the legacy undecorated start/end. */
+    startEnding?: ShapeObject['startEnding'] | null;
+    endEnding?: ShapeObject['endEnding'] | null;
+};
+type SharedTextPatch = Partial<Pick<TextObject, 'text' | 'fontSize' | 'rotation' | 'bold' | 'italic' | 'align' | 'lineHeight' | 'letterSpacing' | 'underline' | 'opacity'>> & {
+    /** null clears the per-object override and restores chart-theme inheritance. */
+    fontFamily?: string | null;
+    color?: string | null;
+    width?: number | null;
+    background?: TextBackground | null;
+    /**
+     * Swap a venue icon's vector symbol. Must be a known registry key (fail-closed).
+     * Only valid on `semanticKind:'icon'` objects.
+     */
+    iconKey?: string;
+};
+
+interface BookableGridArrayInput {
+    floorId?: string;
+    objectIds: string[];
+    rows: number;
+    columns: number;
+    stepX: number;
+    stepY: number;
+}
+interface BookableGridArrayPreview {
+    floorId: string;
+    kind: 'table' | 'booth';
+    sourceIds: string[];
+    sourceCount: number;
+    cells: number;
+    createdCount: number;
+    addedInventory: number;
+    resultingInventory: number;
+    provenanceRemovedCount: number;
+}
+declare function previewBookableGridArray(doc: ChartDoc, input: BookableGridArrayInput): BookableGridArrayPreview;
+declare function addBookableGridArray(doc: ChartDoc, input: BookableGridArrayInput & {
+    idFactory: ChartObjectIdFactory;
+}): BookableGridArrayPreview & {
+    createdIds: string[];
+};
+
+interface SeatRef {
+    rowId: string;
+    index: number;
+}
+/** Semantic fields shared by Designer bulk editing and coordinate-free callers. */
+interface SharedSeatOverridePatch {
+    skip?: boolean | null;
+    label?: string | null;
+    displayLabel?: string | null;
+    categoryKey?: string | null;
+    accessibility?: AccessibilityType[] | null;
+    wheelchairSpaceType?: SeatOverride['wheelchairSpaceType'] | null;
+    commercial?: SeatOverride['commercial'] | null;
+    viewFromSeatUrl?: string | null;
+    viewFromSeatMeta?: SeatViewMetadata | null;
+    /** Merge per-seat label size/color (see LabelStylePatch); null clears it. */
+    labelStyle?: LabelStylePatch | null;
+    /** Designer-only geometry nudges. MCP wrappers deliberately do not expose these. */
+    dx?: number | null;
+    dy?: number | null;
+}
+/** Stable seat identity is its row/table owner plus immutable numeric slot. The
+ * historical `rowId` property name remains wire-compatible for row callers. */
+declare function seatRefId(ref: SeatRef): string;
+declare function parseSeatRefId(seatId: string): SeatRef;
+/**
+ * Apply one atomic seat override edit. A literal non-empty label is single-seat
+ * only; bulk callers use labelPrefix so generated labels stay unique.
+ */
+declare function updateSeatOverrides(doc: ChartDoc, input: {
+    floorId?: string;
+    seats: SeatRef[];
+    patch: SharedSeatOverridePatch;
+    labelPrefix?: string;
+    displayLabelPrefix?: string;
+}): {
+    floorId: string;
+    changed: boolean;
+    seatIds: string[];
+};
+/** Remove every override from the requested seats as one atomic operation. */
+declare function resetSeatOverrides(doc: ChartDoc, input: {
+    floorId?: string;
+    seats: SeatRef[];
+}): {
+    floorId: string;
+    changed: boolean;
+    seatIds: string[];
+};
+
+declare function updateRows(doc: ChartDoc, input: {
+    floorId?: string;
+    rowIds: string[];
+    patch: SharedRowPatch;
+    preserveCenterOnSeatCountChange?: boolean;
+}): {
+    floorId: string;
+    changed: boolean;
+    rowIds: string[];
+};
+interface MergeRowsResult {
+    floorId: string;
+    changed: true;
+    rowId: string;
+    removedRowIds: string[];
+    seatCount: number;
+}
+/**
+ * Merge 2+ roughly-collinear straight rows into one row, concatenating their seat
+ * runs. The geometrically first (lowest-projection) row survives and keeps its
+ * identity/label/category/numbering; the merged run is laid uniformly from its
+ * seat 0 at its own spacing. Overrides from every row are re-based onto the
+ * combined seat index. Refuses when a row is bent/path, the rows aren't parallel,
+ * they don't lie on one line, or the merged run would exceed 300 seats.
+ */
+declare function mergeRows(doc: ChartDoc, input: {
+    floorId?: string;
+    rowIds: string[];
+}): MergeRowsResult;
+interface SplitRowResult {
+    floorId: string;
+    changed: true;
+    rowId: string;
+    newRowId: string;
+    firstSeatCount: number;
+    secondSeatCount: number;
+    newLabel: string;
+}
+/**
+ * Split one row into two at a seat position (1..seatCount-1): the first row keeps
+ * seats [0, index) and its identity; a new row takes seats [index, seatCount) with
+ * a derived free label. Seat positions are reproduced exactly — for a circular-arc
+ * row the second row's origin/rotation/curve are recomputed so its seats land on
+ * the originals. Per-seat overrides move with their physical seat (re-based on the
+ * second row). Refuses on a free-form (exact-path) row.
+ */
+declare function splitRow(doc: ChartDoc, input: {
+    floorId?: string;
+    rowId: string;
+    index: number;
+    idFactory: ChartObjectIdFactory;
+}): SplitRowResult;
+interface RowBlockSpacingResult {
+    floorId: string;
+    changed: boolean;
+    rowIds: string[];
+    gap: number;
+}
+/**
+ * Set a uniform perpendicular gap between 2+ selected rows, repositioning them
+ * along their common normal while preserving each row's position along the shared
+ * row direction. The lowest-projection row stays put; the rest snap to
+ * base + rank·gap. One logical op.
+ */
+declare function setRowBlockSpacing(doc: ChartDoc, input: {
+    floorId?: string;
+    rowIds: string[];
+    gap: number;
+}): RowBlockSpacingResult;
+interface StraightenAndSpaceResult {
+    floorId: string;
+    changed: boolean;
+    rowIds: string[];
+    gap: number;
+}
+/**
+ * One-shot tidy for 2+ selected rows: (a) straighten every row (curve→0, exact
+ * path dropped), (b) align them parallel to the selection's average heading, and
+ * (c) distribute them at a uniform gap equal to the current mean row gap. One
+ * logical op. Overrides are untouched (seat counts and their order are preserved).
+ */
+declare function straightenAndSpaceRows(doc: ChartDoc, input: {
+    floorId?: string;
+    rowIds: string[];
+}): StraightenAndSpaceResult;
+
+interface JoinGAAreasPreview {
+    floorId: string;
+    areaId: string;
+    survivorLabel: string;
+    removedAreaIds: string[];
+    sourceAreaCount: number;
+    capacity: number;
+    inventorySegmentCount: number;
+    outerVertexCount: number;
+    holeCount: number;
+    sectionId: string;
+    /** Computed geometry is returned for a non-mutating canvas preview and is
+     * regenerated by the apply path rather than trusted as client input. */
+    points: Point[];
+    holes?: Point[][];
+}
+/** Non-mutating, deterministic Join Areas preview. No client coordinates are accepted. */
+declare function previewJoinGAAreas(doc: ChartDoc, input: {
+    floorId?: string;
+    gaAreaIds: string[];
+}): JoinGAAreasPreview;
+/** Join 2+ compatible same-floor GA polygons as one atomic document mutation. */
+declare function joinGAAreas(doc: ChartDoc, input: {
+    floorId?: string;
+    gaAreaIds: string[];
+}): JoinGAAreasPreview & {
+    changed: true;
+};
+
+/**
+ * Stage geometry — turns a compact `StageSpec` into a closed polygon the
+ * renderer can draw with its existing polygon path (`renderShape` → Konva
+ * `Line{closed:true}`). This is deliberately dependency-free geometry: every
+ * stage kind (even the curved ones) is emitted as a sampled `Point[]`, so a
+ * stage renders TODAY as a `ShapeObject{kind:'polygon'}` with zero renderer
+ * changes. The Batch-C renderer upgrade (gradient fill, styled label, stage
+ * role) is then a pure enhancement on top of correct geometry.
+ *
+ * Convention (matches the venue layout): the AUDIENCE sits on the +y side, so
+ * a stage's "front" edge is its +y (bottom) edge and curved/thrust stages bulge
+ * toward +y. `rotation` is in degrees clockwise (same as RowObject.rotation),
+ * applied about the stage center — so a stage can face any direction.
+ */
+
+type StageKind = 'rect' | 'rounded' | 'arc' | 'thrust' | 'runway' | 'round';
+
+declare function updateShapes(doc: ChartDoc, input: {
+    floorId?: string;
+    shapeIds: string[];
+    patch: SharedShapePatch;
+}): {
+    floorId: string;
+    changed: boolean;
+    shapeIds: string[];
+};
+/** Resize non-bookable décor around its current visual centre. This is the
+ * shared semantic counterpart to Designer size sliders: callers choose the
+ * resulting size without handling x/y coordinates or individual vertices. */
+declare function resizeShapes(doc: ChartDoc, input: {
+    floorId?: string;
+    updates: Array<{
+        shapeId: string;
+        width: number;
+        height: number;
+    }>;
+}): {
+    floorId: string;
+    changed: boolean;
+    shapes: Array<{
+        id: string;
+        width: number;
+        height: number;
+    }>;
+};
+/** Regenerate first-class stage polygons from stable ids and semantic kind enums. */
+declare function updateStageKinds(doc: ChartDoc, input: {
+    floorId?: string;
+    updates: Array<{
+        stageId: string;
+        stageKind: StageKind;
+    }>;
+}): {
+    floorId: string;
+    changed: boolean;
+    stages: Array<{
+        id: string;
+        stageKind: StageKind;
+    }>;
+};
+
+declare function updateTables(doc: ChartDoc, input: {
+    floorId?: string;
+    tableIds: string[];
+    patch: SharedTablePatch;
+}): {
+    floorId: string;
+    changed: boolean;
+    tableIds: string[];
+};
+declare function updateBooths(doc: ChartDoc, input: {
+    floorId?: string;
+    boothIds: string[];
+    patch: SharedBoothPatch;
+}): {
+    floorId: string;
+    changed: boolean;
+    boothIds: string[];
+};
+declare function updateGAAreas(doc: ChartDoc, input: {
+    floorId?: string;
+    gaAreaIds: string[];
+    patch: SharedGAAreaPatch;
+}): {
+    floorId: string;
+    changed: boolean;
+    gaAreaIds: string[];
+};
+/** Update non-bookable shape presentation. MCP wrappers expose label/fill only. */
+/**
+ * How much bookable inventory an opening (hole) at `polygon` would move out of
+ * its section under today's whole-object, centre-based ownership rule. A row or
+ * table whose centre enters the opening contributes every real unskipped chair;
+ * a crossing object whose centre stays outside contributes none. GA areas retain
+ * aggregate capacity and booths remain atomic. This keeps the warning aligned
+ * with actual Section membership rather than implying unsupported seat-level
+ * ownership. Sections and décor are not inventory, so they never count.
+ */
+declare function countCoveredInventory(objects: ChartObject[], polygon: Point[]): number;
+/** Remove existing top-level chart objects by stable id, preserving every unselected object exactly. */
+declare function removeChartObjects(doc: ChartDoc, input: {
+    floorId?: string;
+    objectIds: string[];
+}): {
+    floorId: string;
+    changed: true;
+    removedObjects: Array<{
+        id: string;
+        type: ChartObject['type'];
+    }>;
+    removedInventory: number;
+    remainingObjectCount: number;
+};
+/** Update free-text presentation while preserving its stable position. */
+declare function updateTextObjects(doc: ChartDoc, input: {
+    floorId?: string;
+    textIds: string[];
+    patch: SharedTextPatch;
+}): {
+    floorId: string;
+    changed: boolean;
+    textIds: string[];
+};
+declare function relabelChartRows(doc: ChartDoc, input: {
+    floorId?: string;
+    rowIds: string[];
+    options: RelabelOptions;
+}): {
+    floorId: string;
+    changed: boolean;
+    rows: Array<{
+        id: string;
+        label: string;
+    }>;
+};
+declare function insertSeatingBlock(doc: ChartDoc, input: {
+    floorId?: string;
+    blockKey: string;
+    center: Point;
+    idFactory: ChartObjectIdFactory;
+}): {
+    floorId: string;
+    blockKey: string;
+    createdIds: string[];
+    sectionId: string | null;
+};
+
+export { type AddBoothArrayInput, type AddGAAreaInput, type AddRowBlockInput, type AddTableArrayInput, type ArcFanRowsInput, type ArcFanRowsPreview, type AutomaticPlacement, type BookableGridArrayInput, type BookableGridArrayPreview, COLORBLIND_SAFE_PALETTE, type ChartObjectIdFactory, ChartOperationError, DEFAULT_FLOOR_HEIGHT_STEP_M, type GeneratedSectionPolygonConversionPreview, type JoinGAAreasPreview, type LabelStylePatch, MAX_FLOOR_BASE_HEIGHT_M, type MergeRowsResult, type PolygonHolePreview, type ReassignColorblindSafeResult, type ReferenceScanApplyResult, type ReferenceScanPreview, type ReferenceScanRowsOptions, type ReferenceScanSectionOutcome, type ReferenceScanSkippedSection, type ReplaceRowBlockInput, type ReplaceRowBlockResult, type ResolveCreationCategoryOptions, type RowBlockSpacingResult, type RowCubicPathPreview, type SeatRef, type SectionBoundaryTransform, type SectionBoundaryTransformResult, type SectionInventorySelectionSummary, type SectionRowFitInput, type SectionRowFitPreview, type SegmentedRowGroupResult, type SharedBoothPatch, type SharedCategoryPatch, type SharedGAAreaPatch, type SharedRowPatch, type SharedSeatOverridePatch, type SharedSectionMetadataPatch, type SharedShapePatch, type SharedTablePatch, type SharedTextPatch, type SharedThemePatch, type SharedZonePatch, type SplitRowResult, type StraightenAndSpaceResult, addArcFanRows, addBookableGridArray, addBoothArray, addChartCategory, addChartFloor, addChartZone, addGAArea, addRowBlock, addTableArray, applyPolygonHole, applyReferenceScanRows, applySectionCornerSmoothing, applySectionOutlineShaping, applySectionRowFit, arcFanInputForGroup, assignSectionInventoryCategory, automaticPlacementCenter, confirmReferenceCategoryOutputColor, convertGeneratedSectionToPolygon, countCoveredInventory, familyCategoryLabel, gaAreaFootprint, groupRowsAsSegmented, insertSeatingBlock, joinGAAreas, mergeRows, mirrorFirstFloor, parseSeatRefId, pickColorblindSafeCategoryColor, previewArcFanRows, previewBookableGridArray, previewGeneratedSectionPolygonConversion, previewJoinGAAreas, previewPolygonHole, previewRemovePolygonHole, previewRowCubicPath, previewSectionRowFit, reassignColorblindSafeCategoryColors, relabelChartRows, removeChartCategory, removeChartFloor, removeChartObjects, removeChartZone, removePolygonHole, renameChartFloor, reorderChartCategories, replaceArcFanRows, replaceRowBlock, resetSeatOverrides, resizeShapes, resolveCreationCategory, seatRefId, sectionInventorySelectionSummary, setRowBlockSpacing, splitRow, straightenAndSpaceRows, transformSectionBoundary, transformSectionBoundaryObject, ungroupSegmentedRow, updateBooths, updateCategoryDefinitions, updateChartFloorBaseHeight, updateChartTheme, updateChartZones, updateGAAreas, updateRowCubicPath, updateRows, updateSeatOverrides, updateSectionExactPath, updateSectionMetadata, updateSegmentedRow, updateShapes, updateStageKinds, updateTables, updateTextObjects, updateViewFromSeatFallback };