@ferscloud/fers-calculation-web 0.2.39 → 0.2.42

package/fers-models.d.ts

@@ -0,0 +1,2513 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+export type paths = Record<string, never>;
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        /**
+         * @description How a member force is reduced to a single value along the member.
+         *     Internally tagged (`{"type": …}`) so every variant is an object — a mixed
+         *     bare-string/object `oneOf` breaks the cloud TS generator.
+         */
+        Aggregation: {
+            /** @enum {string} */
+            type: "MaxAbs";
+        } | {
+            /** @enum {string} */
+            type: "Max";
+        } | {
+            /** @enum {string} */
+            type: "Min";
+        } | {
+            /** Format: double */
+            fraction: number;
+            /** @enum {string} */
+            type: "AtFraction";
+        } | {
+            /** @enum {string} */
+            type: "Start";
+        } | {
+            /** @enum {string} */
+            type: "End";
+        };
+        /** @description Everything that defines a run of the solver against a [`super::model::Model`]. */
+        Analysis: {
+            buckling?: null | components["schemas"]["BucklingAnalysisSettings"];
+            /** @default [] */
+            imperfection_cases: components["schemas"]["ImperfectionCase"][];
+            /** @default [] */
+            load_cases: components["schemas"]["LoadCase"][];
+            /** @default [] */
+            load_combinations: components["schemas"]["LoadCombination"][];
+            modal?: null | components["schemas"]["ModalAnalysisSettings"];
+            /** @description Solver options (first/second order, tolerances, self-weight, gravity, …). */
+            options: components["schemas"]["AnalysisOptions"];
+            seismic?: null | components["schemas"]["SeismicAnalysisSettings"];
+            /**
+             * @description Post-processing unity checks evaluated against the results.
+             * @default []
+             */
+            unity_checks: components["schemas"]["UnityCheckDefinition"][];
+        };
+        /** @description Solver options for an analysis run: analysis order (first/second), tolerances, rigid-member strategy, self-weight and gravity. */
+        AnalysisOptions: {
+            /** Format: double */
+            axial_slack?: number;
+            dimensionality: components["schemas"]["Dimensionality"];
+            /**
+             * @description When true, the engine generates self-weight (dead load) for every member
+             *     from its material density and cross-sectional area, collected into a
+             *     self-weight load case (see `self_weight_load_case_id`).  Cable members
+             *     carry their weight intrinsically in the catenary formulation and are
+             *     therefore excluded from the generated self-weight load.
+             * @default false
+             */
+            enable_self_weight: boolean;
+            /**
+             * @description Global gravity direction as a vector (normalized to a unit vector at use).
+             *     Default `(0, -1, 0)` — gravity acting in the negative Y direction.
+             * @default [
+             *       0,
+             *       -1,
+             *       0
+             *     ]
+             */
+            gravity_direction: components["schemas"]["Vector3"];
+            /**
+             * Format: double
+             * @description Signed gravitational acceleration magnitude in **m/s² (SI)**, the same in
+             *     every unit system (it is NOT rescaled with the model's length unit).
+             *     Default `-9.81`.  Self-weight per unit length is
+             *     `w = density · area · |gravity_factor|` applied along `gravity_direction`,
+             *     and a member `weight` override maps to modal mass as `weight / |gravity_factor|`.
+             * @default -9.81
+             */
+            gravity_factor: number;
+            /**
+             * @description When true, each member result carries a sampled deflected-shape polyline
+             *     (`member_displacements`): the member's global displacement at evenly-spaced
+             *     stations, from cubic-Hermite interpolation of the end-node translations +
+             *     rotations. Off by default to keep the result payload lean.
+             * @default false
+             */
+            include_member_deflected_shape: boolean;
+            /**
+             * @description When true, the solver embeds the single consolidated unity-check HTML
+             *     report in `results.report_html`. Default false (keeps results JSON lean;
+             *     the CLI `--report` flag writes the report to a file instead).
+             * @default false
+             */
+            include_report_html: boolean;
+            /**
+             * @description When false, suppresses shear-center eccentricity coupling (T^T·K·T
+             *     transformation) by clearing y_s/z_s for all sections.  Some commercial
+             *     solvers do not apply this coupling; disabling it improves agreement.
+             * @default true
+             */
+            include_shear_center_coupling: boolean;
+            /**
+             * @description When false, forces shear deformation factor φ=0 (Euler-Bernoulli) for all elements.
+             * @default true
+             */
+            include_shear_deformation: boolean;
+            /**
+             * @description When false, ignores warping constant Iw and uses pure GJ/L torsion for all elements.
+             * @default true
+             */
+            include_warping: boolean;
+            /** Format: int32 */
+            max_iterations?: number | null;
+            /**
+             * @description Controls the nonlinear solver formulation (P_DELTA or COROTATIONAL).
+             *     Only affects second-order (nonlinear) analysis.
+             */
+            nonlinear_method?: components["schemas"]["NonlinearMethod"];
+            order: components["schemas"]["AnalysisOrder"];
+            /**
+             * @description Controls the geometric stiffness matrix formulation for P-Delta analysis.
+             *     `Consistent` (default) uses full Przemieniecki K_g; `Simplified` uses
+             *     P/L-only diagonal terms matching commercial solvers.
+             */
+            pdelta_formulation?: components["schemas"]["PdeltaFormulation"];
+            /**
+             * @description High-level P-Delta strategy.  `Full` (default) amplifies all directions.
+             *     `InPlaneOnly` auto-detects the out-of-plane axis from the model's
+             *     bounding box and suppresses it, matching commercial solver behavior.
+             *     Overrides `pdelta_suppress_axes` when set to `InPlaneOnly`.
+             */
+            pdelta_mode?: components["schemas"]["PdeltaMode"];
+            /**
+             * @description Global translational axes to exclude from P-Delta amplification.
+             *
+             *     When a structure is near buckling in an out-of-plane direction,
+             *     the consistent P-Delta amplification can produce forces that differ
+             *     significantly from commercial solvers which
+             *     typically only amplify in-plane sway.
+             *
+             *     Set to `["Z"]` for in-plane racks/portal frames where Z is out-of-plane,
+             *     or `["X","Z"]` to limit P-Delta to Y-sway only.  Empty (default) means
+             *     all translational directions are amplified.
+             *
+             *     Maps to global DOFs: "X"→0,7  "Y"→1,8  "Z"→2,9  per element.
+             */
+            pdelta_suppress_axes?: string[];
+            /**
+             * @description When true, fill each unity check's per-entity `rendered_report` from its
+             *     `report_template` (rendered against the entity's computed trace). Default
+             *     false for speed; orthogonal to `include_report_html` — narratives appear in
+             *     the consolidated HTML only when this is also true.
+             * @default false
+             */
+            render_unity_reports: boolean;
+            rigid_strategy: components["schemas"]["RigidStrategy"];
+            /**
+             * Format: int32
+             * @description Target load case id that generated self-weight loads are injected into.
+             *     When set, the loads are added to that (typically empty "G") load case so
+             *     combinations can factor it (e.g. 1.35·G).  When `None` and self-weight is
+             *     enabled, a new load case is created automatically.
+             */
+            self_weight_load_case_id?: number | null;
+            solve_loadcases: boolean;
+            /** Format: double */
+            tolerance: number;
+        };
+        /**
+         * @description Python:
+         *     class AnalysisOrder(Enum):
+         *         LINEAR = "LINEAR"
+         *         NONLINEAR = "NONLINEAR"
+         * @enum {string}
+         */
+        AnalysisOrder: "LINEAR" | "NONLINEAR";
+        /**
+         * @description A global coordinate axis.
+         * @enum {string}
+         */
+        Axis: "X" | "Y" | "Z";
+        /**
+         * @description Request for a linear (eigenvalue) buckling analysis: solve
+         *     `K·φ = λ·(−K_g)·φ` where `K_g` is the geometric stiffness from the
+         *     reference load's first-order stress state. Reports the lowest positive
+         *     critical load factors `α_cr = λ` and their buckling mode shapes.
+         */
+        BucklingAnalysisSettings: {
+            /**
+             * Format: int32
+             * @description Maximum subspace-iteration sweeps. Defaults to 100 when omitted.
+             */
+            max_iterations?: number | null;
+            /**
+             * Format: int32
+             * @description Number of buckling modes (lowest positive critical factors) to extract.
+             */
+            num_modes: number;
+            /**
+             * @description Reference load whose first-order stress state drives the geometric
+             *     stiffness `K_g`.
+             */
+            reference: components["schemas"]["EigenLoadRef"];
+            /**
+             * Format: double
+             * @description Eigen convergence tolerance (relative change in the tracked eigenvalues
+             *     between subspace sweeps). Defaults to 1e-6 when omitted.
+             */
+            tolerance?: number | null;
+        };
+        /**
+         * @description Eurocode buckling curve (EN 1993-1-1 Table 6.1/6.2). Maps to imperfection
+         *     factor α: a0=0.13, a=0.21, b=0.34, c=0.49, d=0.76.
+         * @enum {string}
+         */
+        BucklingCurve: "A0" | "A" | "B" | "C" | "D";
+        /** @description A single linear buckling mode. */
+        BucklingMode: {
+            /**
+             * Format: double
+             * @description Critical load factor `α_cr = λ`. The structure buckles when the reference
+             *     load is scaled by this factor (EN 1993-1-1 §5.2.1).
+             */
+            critical_load_factor: number;
+            /**
+             * @description Buckling mode shape: per-node displacement pattern (normalized so the
+             *     largest translational component is 1).
+             */
+            displacements: {
+                [key: string]: components["schemas"]["NodeDisplacement"];
+            };
+            /**
+             * Format: int32
+             * @description 1-based mode number (1 = lowest critical load factor).
+             */
+            mode: number;
+        };
+        /**
+         * @description A buckling restraint located at a node along a member set (one physical beam).
+         *
+         *     Restraints are named by the local member axis they hold (not strong/weak,
+         *     which depends on the section orientation). The spacing between consecutive
+         *     nodes that restrain a given local direction yields the unrestrained length
+         *     used for the corresponding buckling check; restraining twist gives a
+         *     lateral-torsional restraint. The actual buckling-length computation is
+         *     performed by the design-check module; this struct only carries the restraint
+         *     definition through the model.
+         */
+        BucklingRestraint: {
+            /**
+             * Format: int32
+             * @description Node (on one of the member set's members) where the restraint acts.
+             */
+            node_id: number;
+            /** @description Restrains displacement along the member's local y axis. */
+            restrains_local_y?: boolean;
+            /** @description Restrains displacement along the member's local z axis. */
+            restrains_local_z?: boolean;
+            /**
+             * @description Restrains twist (rotation about the local x axis), i.e. a
+             *     lateral-torsional restraint.
+             */
+            restrains_torsion?: boolean;
+        };
+        /**
+         * @description Results of a linear (eigenvalue) buckling analysis: the lowest positive
+         *     critical load factors and their buckling mode shapes.
+         */
+        BucklingResults: {
+            modes: components["schemas"]["BucklingMode"][];
+        };
+        /**
+         * @description One line of the transparent hand-calc: a symbolic formula, the same formula
+         *     with real numbers substituted, and the resulting value + unit (display units).
+         */
+        CalcStep: {
+            formula: string;
+            label: string;
+            substituted: string;
+            unit: string;
+            /** Format: double */
+            value: number;
+        };
+        /**
+         * @description The evaluator kind. Open union — new codes (AISC, …) add variants; the
+         *     result/report/colour layer is identical for every variant.
+         */
+        CheckSpec: {
+            Generic: components["schemas"]["GenericSpec"];
+        } | {
+            Ec3Steel: components["schemas"]["Ec3SteelSpec"];
+        };
+        /**
+         * @description Physical dimension a [`QuantitySource::DimensionedConstant`] carries, so its
+         *     trace value is scaled + labelled consistently with the quantities it is
+         *     compared against. Serialized in the input schema (unlike runtime [`Dimension`]).
+         * @enum {string}
+         */
+        ConstantDimension: "Length" | "Force" | "Moment" | "Stress" | "Area" | "Angle";
+        /**
+         * @description Transverse deflection component, measured relative to the entity's end-to-end
+         *     chord (local-frame axes perpendicular to the chord).
+         * @enum {string}
+         */
+        DeflectionComponent: "LocalY" | "LocalZ" | "Magnitude";
+        /**
+         * @description Unit of mass density used by every `Material.density` in the model.
+         *
+         *     Chosen **independently** of `lengthUnit` — a mm/N model may still declare
+         *     `kg/m3` and pass raw values like structural steel's `7850`. Accepted JSON
+         *     tokens are the ASCII strings `"kg/m3"` and `"kg/mm3"` (digit `3`, not the
+         *     superscript `³`); both normalise to SI (kg/m³) internally regardless of the
+         *     length unit. Default: `"kg/m3"`.
+         * @enum {string}
+         */
+        DensityUnit: "kg/m3" | "kg/mm3";
+        /**
+         * @description Python:
+         *     class Dimensionality(Enum):
+         *         TWO_DIMENSIONAL = "2D"
+         *         THREE_DIMENSIONAL = "3D"
+         * @enum {string}
+         */
+        Dimensionality: "2D" | "3D";
+        /**
+         * @description Directional combination rule across excitation directions.
+         * @enum {string}
+         */
+        DirectionalCombination: "SRSS" | "PERCENT30";
+        /**
+         * @description Nodal displacement component.
+         * @enum {string}
+         */
+        DispComponent: "Dx" | "Dy" | "Dz" | "Rx" | "Ry" | "Rz" | "Magnitude";
+        /** @description A linearly varying distributed load applied along a member over a fractional span (start/end magnitudes). */
+        DistributedLoad: {
+            direction: components["schemas"]["Vector3"];
+            /** Format: double */
+            end_frac: number;
+            /** Format: double */
+            end_magnitude: number;
+            /** Format: int32 */
+            id: number;
+            /** Format: double */
+            magnitude: number;
+            /** Format: int32 */
+            member: number;
+            /** Format: double */
+            start_frac: number;
+        };
+        /**
+         * @description EN 1993-1-1 (steel) design parameters for a section. Engineer-supplied
+         *     (we don't auto-classify — flange/web geometry isn't stored). Namespaced under
+         *     `Section.ec3` so other codes (e.g. AISC) can add their own block without
+         *     polluting the universal section properties.
+         */
+        Ec3SectionParams: {
+            /**
+             * Format: double
+             * @description Effective area for class 4 sections (EN 1993-1-5 §4.3), in the model's
+             *     area unit. Required together with `wel_y_eff` to run EC3 checks on a
+             *     class 4 section.
+             */
+            a_eff?: number | null;
+            buckling_curve_lt?: null | components["schemas"]["BucklingCurve"];
+            buckling_curve_y?: null | components["schemas"]["BucklingCurve"];
+            buckling_curve_z?: null | components["schemas"]["BucklingCurve"];
+            /**
+             * Format: int32
+             * @description Cross-section class 1–4 (EN 1993-1-1 §5.5). Class 4 needs effective
+             *     properties (currently a limitation — see the EC3 evaluator).
+             */
+            section_class?: number | null;
+            /**
+             * Format: double
+             * @description Effective elastic section modulus about y (major axis) for class 4
+             *     sections (EN 1993-1-5), in the model's section-modulus unit.
+             */
+            wel_y_eff?: number | null;
+            /**
+             * Format: double
+             * @description Effective elastic section modulus about z (minor axis) for class 4
+             *     sections (EN 1993-1-5), in the model's section-modulus unit.
+             */
+            wel_z_eff?: number | null;
+            /**
+             * Format: double
+             * @description Mono-symmetry parameter `z_j` (EN 1993-1-1 / NCCI SN030) in the model's
+             *     length unit; 0 for doubly-symmetric sections. Enables the general LTB
+             *     `M_cr` (used with the spec's C2/C3/z_g).
+             */
+            z_j?: number | null;
+        };
+        /** @description Built-in EN 1993-1-1 steel member check (§6.2 cross-section + §6.3 buckling). */
+        Ec3SteelSpec: {
+            /**
+             * Format: double
+             * @description LTB moment-distribution factor C1. When omitted it is computed from the
+             *     member's actual moment diagram (NCCI SN003 quarter-point formula); set it
+             *     explicitly to override (e.g. 1.0 = conservative uniform moment).
+             */
+            c1?: number | null;
+            /**
+             * Format: double
+             * @description LTB factors C2 / C3 for the general `M_cr` (load height / mono-symmetry).
+             *     Default 0.0 → the doubly-symmetric form (no load-height or z_j term).
+             * @default 0
+             */
+            c2: number;
+            /**
+             * Format: double
+             * @default 0
+             */
+            c3: number;
+            /**
+             * Format: double
+             * @default 1
+             */
+            gamma_m0: number;
+            /**
+             * Format: double
+             * @default 1
+             */
+            gamma_m1: number;
+            /** @default true */
+            include_buckling: boolean;
+            /** @default true */
+            include_ltb: boolean;
+            interaction_method?: components["schemas"]["InteractionMethod"];
+            /**
+             * Format: double
+             * @description Transverse-load application height `z_g` above the shear centre (model
+             *     length units). Positive = destabilising (load above shear centre).
+             *     Default 0.0 (load at the shear centre).
+             * @default 0
+             */
+            z_g: number;
+        };
+        /**
+         * @description Which load drives the reference stress state for a linear buckling analysis.
+         *     Its first-order member axial forces scale linearly with the load, so the
+         *     returned eigenvalue is the critical load factor `α_cr` directly.
+         */
+        EigenLoadRef: {
+            /**
+             * Format: int32
+             * @description Reference a load case by id.
+             */
+            LoadCase: number;
+        } | {
+            /**
+             * Format: int32
+             * @description Reference a load combination by id.
+             */
+            LoadCombination: number;
+        };
+        /**
+         * @description Generic, calculation-agnostic grouping of model entities for UI /
+         *     visualization.  Metadata only — ignored by the solver, surfaced in the
+         *     OpenAPI schema for consumers (mirrors `WorkPlane`/`WorkAxis`).  A group may
+         *     reference any mix of entity kinds via the typed id lists below; each list
+         *     defaults to empty.
+         */
+        EntityGroup: {
+            /** Format: int32 */
+            id: number;
+            member_ids?: number[];
+            member_set_ids?: number[];
+            name?: string;
+            node_ids?: number[];
+            /** @description Generated plate finite elements. */
+            plate_element_ids?: number[];
+            /** @description Modeled plate surfaces. */
+            plate_surface_ids?: number[];
+            support_ids?: number[];
+            work_axis_ids?: number[];
+            work_plane_ids?: number[];
+        };
+        /**
+         * @description A node named relative to the entity (member) being checked — its own ends, or,
+         *     via the member's `reference_member` / `reference_node`, a paired member/node.
+         *     Lets a check compare against the member it points at, reusably by classification
+         *     (each member carries its own reference).
+         * @enum {string}
+         */
+        EntityNodeRef: "Start" | "End" | "ReferenceMemberStart" | "ReferenceMemberEnd" | "ReferenceNode";
+        /**
+         * @description Which entity a result belongs to. A tagged union (`{"type": …, "<kind>_id": …}`)
+         *     so exactly one target kind is set — consistent with `EntitySelector` and
+         *     `PlatePressureTarget`.
+         */
+        EntityRef: {
+            /** Format: int32 */
+            member_id: number;
+            /** @enum {string} */
+            type: "Member";
+        } | {
+            /** Format: int32 */
+            memberset_id: number;
+            /** @enum {string} */
+            type: "MemberSet";
+        } | {
+            /** Format: int32 */
+            plate_element_id: number;
+            /** @enum {string} */
+            type: "PlateElement";
+        } | {
+            /** Format: int32 */
+            plate_surface_id: number;
+            /** @enum {string} */
+            type: "PlateSurface";
+        };
+        /**
+         * @description Which entities a check applies to. Internally tagged (`{"type": …}`) so every
+         *     variant is an object (a mixed bare-string/object `oneOf` breaks the cloud TS
+         *     generator).
+         */
+        EntitySelector: {
+            /** @enum {string} */
+            type: "AllMembers";
+        } | {
+            ids: number[];
+            /** @enum {string} */
+            type: "Members";
+        } | {
+            ids: number[];
+            /** @enum {string} */
+            type: "MemberSets";
+        } | {
+            /** @enum {string} */
+            type: "MemberClassification";
+            value: string;
+        } | {
+            /** @enum {string} */
+            type: "AllPlates";
+        } | {
+            ids: number[];
+            /** @enum {string} */
+            type: "PlateSurfaces";
+        } | {
+            ids: number[];
+            /** @enum {string} */
+            type: "PlateElements";
+        };
+        /**
+         * @description Which member a property/force quantity resolves against: the entity itself, or
+         *     the member named by its `reference_member`. Defaults to the entity (so existing
+         *     checks are unchanged).
+         * @enum {string}
+         */
+        EntityTarget: "SelfEntity" | "ReferenceMember";
+        /** @description The result of one check for one entity, enveloped over the applicable combos. */
+        EntityUnityResult: {
+            /** Format: double */
+            capacity?: number | null;
+            /** Format: double */
+            demand: number;
+            entity: components["schemas"]["EntityRef"];
+            /** Format: int32 */
+            governing_combination_id?: number | null;
+            /** Format: double */
+            location_x_frac?: number | null;
+            message?: string | null;
+            /** @description Rendered narrative report (from the check's `report_template`), if any. */
+            rendered_report?: string | null;
+            status: components["schemas"]["UnityStatus"];
+            /**
+             * @description Transparent hand-calc trace (symbolic + substituted) in display units.
+             * @default []
+             */
+            trace: components["schemas"]["CalcStep"][];
+            /** Format: double */
+            utilization: number;
+        };
+        /**
+         * @description Per-result solver diagnostics. `errors` mark results that are present but not
+         *     trustworthy (e.g. a second-order load that meets or exceeds the elastic
+         *     critical/buckling load); `warnings` are advisory. Empty in the common case.
+         */
+        ErrorsAndWarnings: {
+            /** @default [] */
+            errors: components["schemas"]["SolverMessage"][];
+            /** @default [] */
+            warnings: components["schemas"]["SolverMessage"][];
+        };
+        /** @description Root FERS document: settings, the structural model, the analysis to run, and (after solving) results. */
+        FERS: {
+            /** @description The analysis definition: solver options + load/imperfection cases. */
+            analysis: components["schemas"]["Analysis"];
+            /** @description The structural model: geometry, topology, materials, workspace. */
+            model: components["schemas"]["Model"];
+            results?: null | components["schemas"]["ResultsBundle"];
+            /**
+             * Format: int32
+             * @description Schema contract version (see [`SCHEMA_VERSION`]). Defaults to the current
+             *     version when omitted so older documents still parse.
+             * @default 2
+             */
+            schema_version: number;
+            /** @description Units + general info (analysis solver options live on `analysis.options`). */
+            settings: components["schemas"]["Settings"];
+        };
+        /** @enum {string} */
+        ForceUnit: "N" | "kN";
+        /** @description Project metadata (name, author, version) shown in reports. */
+        GeneralInfo: {
+            author: string;
+            project_name: string;
+            version: string;
+        };
+        /**
+         * @description A user-authored, templated-formula check. `utilization = demand / capacity`,
+         *     both evaluated in SI; the report shows each step filled in with real numbers.
+         */
+        GenericSpec: {
+            /** @description Capacity (resistance) expression, e.g. `"fy"`. */
+            capacity: string;
+            /**
+             * @description Demand (action effect) expression, e.g.
+             *     `"bending_moment * fibre_distance / second_moment_of_area"`.
+             */
+            demand: string;
+            /**
+             * @description Named variables referenced by `demand`/`capacity` (and, via the computed
+             *     trace, by the check's `report_template`).
+             * @default []
+             */
+            variables: components["schemas"]["VarBinding"][];
+        };
+        /**
+         * @description A geometric quantity.
+         * @enum {string}
+         */
+        GeometryProperty: "Length";
+        /**
+         * @description EN 1998-1 ground type (Table 3.1) selecting the spectrum shape parameters.
+         * @enum {string}
+         */
+        GroundType: "A" | "B" | "C" | "D" | "E";
+        /** @description Geometric imperfections (sway/translation) applied for a set of load combinations. */
+        ImperfectionCase: {
+            /** Format: int32 */
+            imperfection_case_id: number;
+            load_combinations: number[];
+            sway_imperfections: components["schemas"]["SwayImperfection"][];
+            translation_imperfections: components["schemas"]["TranslationImperfection"][];
+        };
+        /**
+         * @description k_ij interaction-factor method for EN 1993-1-1 §6.3.3.
+         * @enum {string}
+         */
+        InteractionMethod: "AnnexA" | "AnnexB";
+        /** @description Lateral-force (equivalent static) method results (§4.3.3.2). */
+        LateralForceResults: {
+            combined: components["schemas"]["Results"];
+            per_direction: components["schemas"]["SeismicDirectionResult"][];
+        };
+        /** @enum {string} */
+        LengthUnit: "mm" | "cm" | "m";
+        /** @enum {string} */
+        LimitState: "SLS" | "ULS" | "FLS" | "ALS";
+        /**
+         * @description The coordinate frame a member point load/moment direction is expressed in.
+         * @enum {string}
+         */
+        LoadAxes: "global" | "local";
+        /** @description A named collection of loads (nodal, distributed, surface, member point loads/moments, plate pressures, imperfections). */
+        LoadCase: {
+            /** @default [] */
+            distributed_loads: components["schemas"]["DistributedLoad"][];
+            /** Format: int32 */
+            id: number;
+            /** @default [] */
+            member_point_loads: components["schemas"]["MemberPointLoad"][];
+            /** @default [] */
+            member_point_moments: components["schemas"]["MemberPointMoment"][];
+            name: string;
+            /** @default [] */
+            nodal_loads: components["schemas"]["NodalLoad"][];
+            /** @default [] */
+            nodal_moments: components["schemas"]["NodalMoment"][];
+            /** @default [] */
+            plate_pressures: components["schemas"]["PlatePressure"][];
+            /** @default [] */
+            surface_loads: components["schemas"]["SurfaceLoad"][];
+        };
+        /** @description One `(load case, factor)` term of a load combination. */
+        LoadCaseFactor: {
+            /** Format: double */
+            factor: number;
+            /** Format: int32 */
+            load_case_id: number;
+        };
+        /** @description A factored combination of load cases for a given limit state (SLS/ULS/FLS/ALS). */
+        LoadCombination: {
+            check: string;
+            /** Format: int32 */
+            id: number;
+            limit_state?: null | components["schemas"]["LimitState"];
+            load_case_factors: components["schemas"]["LoadCaseFactor"][];
+            name: string;
+            situation?: string | null;
+        };
+        /**
+         * @description Distinguishes a concentrated force from a concentrated moment at a node.
+         * @enum {string}
+         */
+        LoadType: "force" | "moment";
+        /**
+         * @description Mass-matrix formulation for modal (natural-frequency) analysis.
+         *
+         *     - **Consistent** (default): full Przemieniecki element mass matrix that
+         *       couples translations and rotations. More accurate, matches the consistent
+         *       stiffness matrix, and is positive-definite on translational + rotational
+         *       DOFs.
+         *     - **Lumped**: diagonal mass matrix (HRZ-style half-mass at each node for the
+         *       translational DOFs only). Simpler and cheaper; rotational/warping DOFs
+         *       carry no inertia, so the mass matrix is only positive-semidefinite. The
+         *       subspace-iteration eigensolver handles the massless DOFs.
+         *
+         *     Python:
+         *     class MassFormulation(Enum):
+         *         CONSISTENT = "CONSISTENT"
+         *         LUMPED = "LUMPED"
+         * @enum {string}
+         */
+        MassFormulation: "CONSISTENT" | "LUMPED";
+        /** @description An isotropic material (E, G, density, yield strength) with optional orthotropic plate properties. */
+        Material: {
+            /** Format: double */
+            density: number;
+            /** Format: double */
+            e_mod: number;
+            /** Format: double */
+            g_mod: number;
+            /** Format: int32 */
+            id: number;
+            name: string;
+            orthotropic_plate?: null | components["schemas"]["OrthotropicPlateMaterial"];
+            /** Format: double */
+            yield_stress: number;
+        };
+        /**
+         * @description A material property.
+         * @enum {string}
+         */
+        MaterialProperty: "E" | "G" | "Fy" | "Density";
+        /** @description A finite-element member between two nodes, with a section, member type and optional end hinges/offsets. */
+        Member: {
+            /**
+             * Format: double
+             * @description Optional user-supplied buckling reduction factor χ (EN 1993-1-1 §6.3).
+             *     Currently informational: the EC3 unity-check evaluator computes its own χ
+             *     from the section's buckling curve and does not yet read this override.
+             */
+            chi?: number | null;
+            /**
+             * @description Free-text grouping key used to target this member in unity checks
+             *     (`EntitySelector::MemberClassification`). `None` = unclassified.
+             */
+            classification?: string | null;
+            /** Format: int32 */
+            end_hinge?: number | null;
+            /** Format: int32 */
+            end_node_id: number;
+            end_offset?: null | components["schemas"]["MemberEndOffset"];
+            /** Format: int32 */
+            id: number;
+            member_type: components["schemas"]["MemberType"];
+            /**
+             * @description When true, the cross-section is mirrored: shear-center offsets y_s and
+             *     z_s are negated, and the shape_path geometry is flipped.
+             */
+            mirror?: boolean;
+            /**
+             * Format: double
+             * @description Initial cable tension (force units) for `Cable` members. Used to derive
+             *     the unstretched length when `unstretched_length` is not given directly:
+             *     `L₀ = L_chord / (1 + pretension/EA)`.  Ignored for non-cable members.
+             */
+            pretension?: number | null;
+            /**
+             * Format: int32
+             * @description Reference member used by the modeler/UI to define this member's orientation
+             *     or grouping. Not used by the solver; preserved for consumers/unity checks.
+             */
+            reference_member?: number | null;
+            /**
+             * Format: int32
+             * @description Reference node used by the modeler/UI (e.g. orientation reference). Not used
+             *     by the solver; preserved for consumers/unity checks.
+             */
+            reference_node?: number | null;
+            /** Format: double */
+            rotation_angle: number;
+            /** Format: int32 */
+            section?: number | null;
+            /** Format: int32 */
+            start_hinge?: number | null;
+            /** Format: int32 */
+            start_node_id: number;
+            start_offset?: null | components["schemas"]["MemberEndOffset"];
+            /**
+             * Format: double
+             * @description Explicit unstretched (natural) length L₀ (length units) for `Cable`
+             *     members.  Takes precedence over `pretension`.  When neither is set, the
+             *     cable's unstretched length defaults to the straight chord length.
+             */
+            unstretched_length?: number | null;
+            /**
+             * Format: double
+             * @description Optional self-weight override as a gravity load **per unit length**, in the
+             *     model's force/length units (already including g). When non-zero it replaces
+             *     the computed `density · area · g` self-weight for this member (see
+             *     `append_self_weight_loads`); `0.0` means "use the computed value".
+             */
+            weight: number;
+        };
+        /**
+         * @description One sampled point on a member's deflected shape: the global displacement
+         *     `[dx, dy, dz]` at fractional position `x_frac ∈ [0, 1]` along the member
+         *     (0 = start node, 1 = end node).
+         */
+        MemberDisplacementSample: {
+            /** @description Global displacement `[dx, dy, dz]` at this station, in model length units. */
+            displacement: components["schemas"]["Vector3"];
+            /**
+             * Format: double
+             * @description Fractional position along the member, 0 (start) … 1 (end).
+             */
+            x_frac: number;
+        };
+        /**
+         * @description A rigid offset between a member end and its node, in the **global** frame
+         *     (`X`, `Y`, `Z`).
+         */
+        MemberEndOffset: {
+            /** Format: double */
+            X?: number;
+            /** Format: double */
+            Y?: number;
+            /** Format: double */
+            Z?: number;
+        };
+        /**
+         * @description Local member force component (member local axes). Used by member unity checks
+         *     (`QuantitySource::MemberForce`) and member-hinge stiffness curves. Distinct
+         *     from [`crate::models::stiffness_curve::SupportForceComponent`], whose global
+         *     `Fx/Fy/Fz` reaction names apply to support stiffness curves.
+         * @enum {string}
+         */
+        MemberForceComponent: "N" | "Vy" | "Vz" | "Mx" | "My" | "Mz" | "Bimoment";
+        /** @description A member end release / spring: translational and rotational stiffnesses with optional nonlinear curves. */
+        MemberHinge: {
+            /**
+             * @description Free-text label for human readability only (e.g. `"Column base"`,
+             *     `"SPRING_YZ"`). The solver ignores this field — actual hinge behavior is
+             *     driven entirely by the release/stiffness fields below. Not a constrained
+             *     value set, so intentionally a `String` rather than an enum.
+             */
+            hinge_type: string;
+            /** Format: int32 */
+            id: number;
+            /** Format: double */
+            max_bimoment_warp?: number | null;
+            /** Format: double */
+            max_moment_mx?: number | null;
+            /** Format: double */
+            max_moment_my?: number | null;
+            /** Format: double */
+            max_moment_mz?: number | null;
+            /** Format: double */
+            max_tension_vx?: number | null;
+            /** Format: double */
+            max_tension_vy?: number | null;
+            /** Format: double */
+            max_tension_vz?: number | null;
+            /** Format: double */
+            rotational_release_mx?: number | null;
+            /** Format: double */
+            rotational_release_my?: number | null;
+            /** Format: double */
+            rotational_release_mz?: number | null;
+            /** Format: double */
+            rotational_release_warp?: number | null;
+            stiffness_curve_mx?: null | components["schemas"]["MemberStiffnessCurve"];
+            stiffness_curve_my?: null | components["schemas"]["MemberStiffnessCurve"];
+            stiffness_curve_mz?: null | components["schemas"]["MemberStiffnessCurve"];
+            stiffness_curve_vx?: null | components["schemas"]["MemberStiffnessCurve"];
+            stiffness_curve_vy?: null | components["schemas"]["MemberStiffnessCurve"];
+            stiffness_curve_vz?: null | components["schemas"]["MemberStiffnessCurve"];
+            /** Format: double */
+            translational_release_vx?: number | null;
+            /** Format: double */
+            translational_release_vy?: number | null;
+            /** Format: double */
+            translational_release_vz?: number | null;
+        };
+        /** @description A concentrated force applied at a fractional position along a member. */
+        MemberPointLoad: {
+            /**
+             * @description Coordinate frame the `direction` is expressed in.
+             * @default global
+             */
+            axes: components["schemas"]["LoadAxes"];
+            /** @description Load direction unit vector (global or local axes). */
+            direction: components["schemas"]["Vector3"];
+            /** Format: int32 */
+            id: number;
+            /** Format: double */
+            magnitude: number;
+            /** Format: int32 */
+            member: number;
+            /**
+             * Format: double
+             * @description Fractional position along the member (0.0 = start, 1.0 = end).
+             */
+            position: number;
+        };
+        /** @description A concentrated moment applied at a fractional position along a member. */
+        MemberPointMoment: {
+            /**
+             * @description Coordinate frame the `direction` is expressed in.
+             * @default global
+             */
+            axes: components["schemas"]["LoadAxes"];
+            /** @description Load direction unit vector (global or local axes). */
+            direction: components["schemas"]["Vector3"];
+            /** Format: int32 */
+            id: number;
+            /** Format: double */
+            magnitude: number;
+            /** Format: int32 */
+            member: number;
+            /**
+             * Format: double
+             * @description Fractional position along the member (0.0 = start, 1.0 = end).
+             */
+            position: number;
+        };
+        /**
+         * @description Per-member result: local/global end forces, envelope maxima/minima, and section forces.
+         *
+         *     ## Sign convention (see also `compute_section_forces` in `functions/results.rs`)
+         *
+         *     - **Frames.** `start_node_forces` / `end_node_forces` are in the **global** frame.
+         *       `local_*` fields and `section_forces` are in the member's **local centroidal**
+         *       frame. For geometrically-nonlinear (corotational) results the local frame is the
+         *       **corotated (deformed-element) frame**, so the bending moment stays in one
+         *       component along a co-linear member chain and section forces interpolate correctly.
+         *     - **Start vs end node.** The two member ends report forces in the static-equilibrium
+         *       ("nodal reaction") convention, so the **end node is the Newton's-3rd-law opposite**
+         *       of the start node and the interior `section_forces`. Plotting
+         *       `[start, …section_forces…, end]` raw therefore draws a `value → −value` sawtooth;
+         *       use [`MemberResult::internal_force_series`] (which negates the end node) for a
+         *       continuous diagram, or negate `local_end_forces` yourself.
+         *     - **Components.** Axial `fx` is **tension-positive**; `fy`/`fz` are shears, `mx` is
+         *       torsion, `my`/`mz` are bending moments, `bw` is the warping bimoment.
+         */
+        MemberResult: {
+            /**
+             * @description Member-end force at the end node, in the **global** frame (Newton's-3rd-law
+             *     opposite of the start-node internal force).
+             */
+            end_node_forces: components["schemas"]["NodeForces"];
+            /**
+             * @description Continuous, ready-to-plot internal force diagram from `x_frac = 0` (start) to
+             *     `x_frac = 1` (end), in the local frame: `local_start_forces`, then
+             *     `section_forces`, then the **negated** `local_end_forces` (converted from the
+             *     Newton's-3rd-law node reaction to the internal-force convention) so the series
+             *     is continuous with no sawtooth across shared nodes.
+             */
+            internal_force_series?: components["schemas"]["SectionForce"][];
+            local_displacement_end_node: components["schemas"]["NodeDisplacement"];
+            local_displacement_start_node: components["schemas"]["NodeDisplacement"];
+            /**
+             * @description Internal force at the end node, in the member **local centroidal** frame.
+             *     This is the nodal-reaction convention, i.e. the Newton's-3rd-law opposite of
+             *     the internal force at the end — negate it to get the continuous internal value.
+             */
+            local_end_forces: components["schemas"]["NodeForces"];
+            /** @description Per-component maxima over the member, in the local frame. */
+            local_maximums: components["schemas"]["NodeForces"];
+            /** @description Per-component minima over the member, in the local frame. */
+            local_minimums: components["schemas"]["NodeForces"];
+            /**
+             * @description Internal force at the start node, in the member **local centroidal** frame
+             *     (corotated frame for nonlinear results). Equals `internal_force_series[0]`.
+             */
+            local_start_forces: components["schemas"]["NodeForces"];
+            /** @description Per-component maxima over the member (global frame). */
+            maximums: components["schemas"]["NodeForces"];
+            /**
+             * @description Optional sampled deflected shape: the member's global displacement at
+             *     evenly-spaced stations from `x_frac = 0` to `1`, reconstructed by
+             *     cubic-Hermite interpolation of the end-node translations + rotations.
+             *     Empty unless `AnalysisOptions::include_member_deflected_shape` is enabled.
+             *     The interpolation is the end-DOF homogeneous cubic — exact for members with
+             *     no span load; under a member UDL the true shape is quartic, so mid-span sag
+             *     is slightly under-rendered (matching client-side Hermite reconstructions).
+             */
+            member_displacements?: components["schemas"]["MemberDisplacementSample"][];
+            /** @description Per-component minima over the member (global frame). */
+            minimums: components["schemas"]["NodeForces"];
+            /**
+             * @description Continuous internal forces at evenly-spaced **interior** fractions
+             *     (`0 < x_frac < 1`), in the local frame. These already follow the internal-force
+             *     convention (no end-node flip). For a ready-to-plot 0→1 diagram including the
+             *     endpoints use [`MemberResult::internal_force_series`].
+             */
+            section_forces: components["schemas"]["SectionForce"][];
+            /** @description Member-end force at the start node, in the **global** frame. */
+            start_node_forces: components["schemas"]["NodeForces"];
+        };
+        /**
+         * @description A member set represents one physical beam: the ordered chain of collinear
+         *     finite-element members that together form a single continuous structural
+         *     member. Members are referenced by id; the member objects themselves live in
+         *     the top-level `FERS.members` list.
+         */
+        MemberSet: {
+            /**
+             * Format: double
+             * @description Buckling-length overrides for code checks (EN 1993-1-1 §6.3). When absent,
+             *     the unity-check evaluator derives L_cr from `buckling_restraints` spacing.
+             *     Explicit lengths (m) take precedence over the factors.
+             */
+            buckling_length_y?: number | null;
+            /** Format: double */
+            buckling_length_z?: number | null;
+            /**
+             * @description Node-based buckling restraints along the beam (replaces scalar l_y/l_z).
+             * @default []
+             */
+            buckling_restraints: components["schemas"]["BucklingRestraint"][];
+            /**
+             * @description Free-text label for the modeler/UI (e.g. "Upright", "Beam"); not used by
+             *     the solver.
+             */
+            classification?: string | null;
+            /**
+             * Format: double
+             * @description Effective-length factor K_y (L_cr,y = K_y · L) when no explicit length given.
+             */
+            effective_length_factor_y?: number | null;
+            /** Format: double */
+            effective_length_factor_z?: number | null;
+            /** Format: int32 */
+            id: number;
+            /**
+             * Format: double
+             * @description Unrestrained length for lateral-torsional buckling (m).
+             */
+            ltb_length?: number | null;
+            /** @description Ids of the members (in `FERS.members`) that make up this beam. */
+            member_ids: number[];
+        };
+        /**
+         * @description A **member-hinge** spring stiffness that varies with a member-local force.
+         *
+         *     `points` is a sorted list of `[force_value, stiffness]` pairs and `depends_on`
+         *     is the member-local force component driving the interpolation. `Bimoment` is
+         *     not a valid curve driver (no slot in the member-end force array).
+         */
+        MemberStiffnessCurve: {
+            /** @description Which member-local force component the stiffness depends on. */
+            depends_on: components["schemas"]["MemberStiffnessCurveDriver"];
+            /** @description Sorted `[force_value, stiffness]` pairs (≥ 2 points, positive stiffness). */
+            points: [
+                number,
+                number
+            ][];
+            /**
+             * @description When `true`, the curve is driven by the SIGNED force, so tension and
+             *     compression can have different stiffness (points may span negative
+             *     force). When `false` (default), the curve is driven by `|force|`
+             *     (symmetric in tension/compression — the legacy behaviour).
+             */
+            signed?: boolean;
+        };
+        /**
+         * @description Which member-local force component a **member-hinge** stiffness curve depends on.
+         *
+         *     A subset of [`crate::models::unitychecks::quantities::MemberForceComponent`]:
+         *     the six member-end force/moment components, excluding `Bimoment` (which has no
+         *     slot in the member-end force array and cannot drive a curve). Keeping a
+         *     dedicated driver enum makes the schema express exactly what is valid.
+         * @enum {string}
+         */
+        MemberStiffnessCurveDriver: "N" | "Vy" | "Vz" | "Mx" | "My" | "Mz";
+        /** @enum {string} */
+        MemberType: "Normal" | "Truss" | "Tension" | "Compression" | "Rigid" | "Cable";
+        /**
+         * @description Request for a modal (natural-frequency) analysis: solve `K·φ = ω²·M·φ` and
+         *     report the lowest `num_modes` natural frequencies and mode shapes. Mass comes
+         *     from the structural self-mass (`density · area`), honoring the per-member
+         *     `weight` override (a gravity force per unit length, so mass/length =
+         *     `weight / |gravity_factor|`).
+         */
+        ModalAnalysisSettings: {
+            /** @description Mass-matrix formulation (Consistent default, Lumped optional). */
+            mass_formulation?: components["schemas"]["MassFormulation"];
+            /**
+             * Format: int32
+             * @description Maximum subspace-iteration sweeps. Defaults to 100 when omitted.
+             */
+            max_iterations?: number | null;
+            /**
+             * Format: int32
+             * @description Number of natural modes (lowest frequencies) to extract.
+             */
+            num_modes: number;
+            /**
+             * Format: double
+             * @description Eigen convergence tolerance (relative change in the tracked eigenvalues
+             *     between subspace sweeps). Defaults to 1e-6 when omitted.
+             */
+            tolerance?: number | null;
+        };
+        /**
+         * @description Modal combination rule for MRSA.
+         * @enum {string}
+         */
+        ModalCombination: "CQC" | "SRSS";
+        /**
+         * @description Results of a modal (natural-frequency) analysis: the lowest natural modes of
+         *     the structure, sorted by ascending frequency.
+         *
+         *     All quantities are SI / time-based and therefore independent of the model's
+         *     length and force units: frequencies in hertz, periods in seconds, masses in
+         *     kilograms. Mode shapes are normalized so the largest translational component
+         *     equals 1 (a unit-free shape); the generalized mass and effective modal mass
+         *     are reported separately for response-spectrum / participation work.
+         */
+        ModalResults: {
+            modes: components["schemas"]["ModeShape"][];
+        };
+        /** @description A single natural vibration mode. */
+        ModeShape: {
+            /**
+             * Format: double
+             * @description Angular frequency `ω` (rad/s).
+             */
+            angular_frequency: number;
+            /**
+             * @description Mode shape: per-node displacement pattern (normalized so the largest
+             *     translational component is 1).
+             */
+            displacements: {
+                [key: string]: components["schemas"]["NodeDisplacement"];
+            };
+            /**
+             * @description Effective modal mass per global direction `[X, Y, Z, RX, RY, RZ]`
+             *     (`Γ² / (φᵀ·M·φ)`, in kg). The sum across modes approaches the total
+             *     free mass of the structure in each direction.
+             */
+            effective_mass: number[];
+            /**
+             * Format: double
+             * @description Eigenvalue `ω²` (rad²/s²).
+             */
+            eigenvalue: number;
+            /**
+             * Format: double
+             * @description Generalized (modal) mass `φᵀ·M·φ` (kg) for the reported, max-translation
+             *     normalized shape.
+             */
+            modal_mass: number;
+            /**
+             * Format: int32
+             * @description 1-based mode number (1 = lowest frequency).
+             */
+            mode: number;
+            /**
+             * Format: double
+             * @description Natural frequency `f = ω / 2π` (Hz).
+             */
+            natural_frequency: number;
+            /**
+             * @description Modal participation factor per global direction
+             *     `[X, Y, Z, RX, RY, RZ]` (`Γ = φᵀ·M·r`).
+             */
+            participation_factors: number[];
+            /**
+             * Format: double
+             * @description Period `T = 1 / f` (s).
+             */
+            period: number;
+        };
+        /**
+         * @description The structural model: nodes, members, plates and their supporting
+         *     definitions (materials, sections, supports, hinges, shape paths).
+         */
+        Model: {
+            materials: components["schemas"]["Material"][];
+            /** @default [] */
+            member_hinges: components["schemas"]["MemberHinge"][];
+            member_sets: components["schemas"]["MemberSet"][];
+            /** @description Single source of truth for member objects. Member sets reference these by id. */
+            members: components["schemas"]["Member"][];
+            nodal_supports: components["schemas"]["NodalSupport"][];
+            nodes: components["schemas"]["Node"][];
+            /** @default [] */
+            plate_elements: components["schemas"]["PlateElement"][];
+            /** @default [] */
+            plate_surfaces: components["schemas"]["PlateSurface"][];
+            sections: components["schemas"]["Section"][];
+            /** @default [] */
+            shape_paths: components["schemas"]["ShapePath"][];
+            /** @default {} */
+            workspace: components["schemas"]["Workspace"];
+        };
+        /** @description Modal response spectrum analysis results (§4.3.3.3). */
+        MrsaResults: {
+            /** @description Final envelope after directional combination. */
+            combined: components["schemas"]["Results"];
+            /** @description Per excitation direction (base shear, modal-mass table, per-direction envelope). */
+            per_direction: components["schemas"]["SeismicDirectionResult"][];
+        };
+        /** @description A concentrated force applied at a node. */
+        NodalLoad: {
+            direction: components["schemas"]["Vector3"];
+            /** Format: int32 */
+            id: number;
+            load_type: components["schemas"]["LoadType"];
+            /** Format: double */
+            magnitude: number;
+            /** Format: int32 */
+            node: number;
+        };
+        /** @description A concentrated moment applied at a node. */
+        NodalMoment: {
+            direction: components["schemas"]["Vector3"];
+            /** Format: int32 */
+            id: number;
+            load_type: components["schemas"]["LoadType"];
+            /** Format: double */
+            magnitude: number;
+            /** Format: int32 */
+            node: number;
+        };
+        /**
+         * @description Boundary conditions at a node: per-axis translation/rotation conditions plus
+         *     optional warping. Each condition is in the **global** frame; an absent
+         *     (`None`) field means that DOF is free.
+         */
+        NodalSupport: {
+            RX?: null | components["schemas"]["SupportCondition"];
+            RY?: null | components["schemas"]["SupportCondition"];
+            RZ?: null | components["schemas"]["SupportCondition"];
+            X?: null | components["schemas"]["SupportCondition"];
+            Y?: null | components["schemas"]["SupportCondition"];
+            Z?: null | components["schemas"]["SupportCondition"];
+            /** @description Free-text label for the modeler/UI; not used by the solver. */
+            classification?: string | null;
+            /** Format: int32 */
+            id: number;
+            warping_condition?: null | components["schemas"]["SupportCondition"];
+        };
+        /** @description A model node with global coordinates and an optional support. */
+        Node: {
+            /** Format: double */
+            X: number;
+            /** Format: double */
+            Y: number;
+            /** Format: double */
+            Z: number;
+            /** Format: int32 */
+            id: number;
+            /** Format: int32 */
+            nodal_support?: number | null;
+        };
+        /** @description Nodal displacement result (translations, rotations and warping). */
+        NodeDisplacement: {
+            /** Format: double */
+            dx: number;
+            /** Format: double */
+            dy: number;
+            /** Format: double */
+            dz: number;
+            /** Format: double */
+            rx: number;
+            /** Format: double */
+            ry: number;
+            /** Format: double */
+            rz: number;
+            /** Format: double */
+            warp?: number;
+        };
+        /**
+         * @description A 6-DOF force/moment set (plus warping bimoment) in a given frame (global or
+         *     member-local, set by the field that owns it). Axial is tension-positive.
+         */
+        NodeForces: {
+            /**
+             * Format: double
+             * @description Warping bimoment ([F·L²]).
+             */
+            bw?: number;
+            /**
+             * Format: double
+             * @description Axial force (tension-positive).
+             */
+            fx: number;
+            /**
+             * Format: double
+             * @description Shear force about the local/global y axis.
+             */
+            fy: number;
+            /**
+             * Format: double
+             * @description Shear force about the local/global z axis.
+             */
+            fz: number;
+            /**
+             * Format: double
+             * @description Torsional moment about the x axis.
+             */
+            mx: number;
+            /**
+             * Format: double
+             * @description Bending moment about the y axis.
+             */
+            my: number;
+            /**
+             * Format: double
+             * @description Bending moment about the z axis.
+             */
+            mz: number;
+        };
+        /** @description A node's global coordinates within a result. */
+        NodeLocation: {
+            /** Format: double */
+            X: number;
+            /** Format: double */
+            Y: number;
+            /** Format: double */
+            Z: number;
+        };
+        /**
+         * @description Controls the nonlinear formulation used for second-order analysis.
+         *
+         *     - **PDelta**: Total-Lagrangian P-Δ.  Geometric stiffness is added to the
+         *       original-frame elastic stiffness. This is the approach used by most
+         *       commercial solvers.  Accurate for moderate
+         *       rotations (< ~10°) but increasingly approximate for larger rotations.
+         *
+         *     - **Corotational** (default): Load-incremental corotational Newton-Raphson.
+         *       The element frame tracks the deformed geometry, so internal forces and
+         *       equilibrium are self-consistent even for large rotations (> 15°).
+         *       For small rotations the results converge to P-Delta.
+         *
+         *     Python:
+         *     class NonlinearMethod(Enum):
+         *         P_DELTA = "P_DELTA"
+         *         COROTATIONAL = "COROTATIONAL"
+         * @enum {string}
+         */
+        NonlinearMethod: "P_DELTA" | "COROTATIONAL";
+        /**
+         * @description Orthotropic in-plane/bending material properties for plates, expressed in the
+         *     plate's local axes (x = `local_x_direction`, y in-plane perpendicular).
+         */
+        OrthotropicPlateMaterial: {
+            /**
+             * Format: double
+             * @description Young's modulus along local x.
+             */
+            e_x: number;
+            /**
+             * Format: double
+             * @description Young's modulus along local y.
+             */
+            e_y: number;
+            /**
+             * Format: double
+             * @description In-plane shear modulus.
+             */
+            g_xy: number;
+            /**
+             * Format: double
+             * @description Transverse shear modulus (x–z); used by Mindlin/thick plates.
+             */
+            g_xz?: number | null;
+            /**
+             * Format: double
+             * @description Transverse shear modulus (y–z); used by Mindlin/thick plates.
+             */
+            g_yz?: number | null;
+            /**
+             * Format: double
+             * @description Major Poisson's ratio (ν_xy); ν_yx is derived from `e_x·ν_yx = e_y·ν_xy`.
+             */
+            nu_xy: number;
+        };
+        /**
+         * @description The kind of drawing operation a [`ShapeCommand`] performs.
+         * @enum {string}
+         */
+        PathCommand: "moveTo" | "lineTo" | "arcTo" | "closePath";
+        /**
+         * @description Controls the geometric stiffness (K_g) formulation for P-Delta analysis.
+         *
+         *     - **Consistent** (default): Full Przemieniecki K_g with 6/5·P/L translation
+         *       terms, bending-axial rotational coupling (P/10, PL/15, PL/30), and
+         *       Wagner torsion.  Most accurate near buckling and for lateral-torsional
+         *       stability; captures both global P-Δ and local P-δ effects.
+         *
+         *     - **Simplified**: Diagonal P/L terms for transverse translations only —
+         *       no rotational coupling, no Wagner torsion.  Matches the P-Delta
+         *       formulation used by most commercial solvers.
+         *       Captures global P-Δ (sway) but not local P-δ (member curvature).
+         *
+         *     Python:
+         *     class PdeltaFormulation(Enum):
+         *         CONSISTENT = "CONSISTENT"
+         *         SIMPLIFIED = "SIMPLIFIED"
+         * @enum {string}
+         */
+        PdeltaFormulation: "CONSISTENT" | "SIMPLIFIED";
+        /**
+         * @description Controls the P-Delta amplification strategy.
+         *
+         *     - **Full** (default): All 3D translational directions are amplified by
+         *       geometric stiffness.  Most rigorous for general 3D structures.
+         *
+         *     - **InPlaneOnly**: Automatically detects the structural plane from the
+         *       model's bounding box and suppresses P-Delta amplification in the
+         *       thinnest (out-of-plane) direction.  Matches the in-plane-only sway
+         *       approach used by most commercial solvers.
+         *       If the model is truly 3D (all three axes have similar extent), no
+         *       axis is suppressed.
+         *
+         *     Python:
+         *     class PdeltaMode(Enum):
+         *         FULL = "FULL"
+         *         IN_PLANE_ONLY = "IN_PLANE_ONLY"
+         * @enum {string}
+         */
+        PdeltaMode: "FULL" | "IN_PLANE_ONLY";
+        /**
+         * @description In-plane (membrane) constitutive assumption.
+         * @enum {string}
+         */
+        PlaneState: "PlaneStress" | "PlaneStrain";
+        /**
+         * @description Structural behavior of a plate.
+         *
+         *     - `Shell` (default): in-plane (membrane) + out-of-plane (bending) behavior.
+         *     - `Membrane`: in-plane only; useful for panels, diaphragms, or fabric-like
+         *       surfaces. Bending stiffness and bending resultants are suppressed.
+         * @enum {string}
+         */
+        PlateBehavior: "Shell" | "Membrane";
+        /** @description A generated finite element of a plate mesh (3-node triangle or 4-node quad). */
+        PlateElement: {
+            /** @default Shell */
+            behavior: components["schemas"]["PlateBehavior"];
+            /** Format: int32 */
+            id: number;
+            local_x_direction?: components["schemas"]["Vector3"];
+            /** Format: int32 */
+            material: number;
+            /** @description Element connectivity: 3 nodes (triangle) or 4 nodes (quad). */
+            node_ids: number[];
+            /**
+             * Format: double
+             * @description Distance from the reference surface along the local plate normal.
+             * @default 0
+             */
+            offset: number;
+            /**
+             * @description In-plane constitutive assumption (plane stress/strain).
+             * @default PlaneStress
+             */
+            plane_state: components["schemas"]["PlaneState"];
+            /**
+             * Format: int32
+             * @description The `PlateSurface` this element was meshed from, if any.
+             */
+            source_surface_id?: number | null;
+            stiffness_modifiers?: null | components["schemas"]["PlateStiffnessModifiers"];
+            /**
+             * @description Finite-element theory (thin/thick/auto).
+             * @default Auto
+             */
+            theory: components["schemas"]["PlateTheory"];
+            /** Format: double */
+            thickness: number;
+        };
+        /**
+         * @description Preferred generated element shape when meshing a [`super::platesurface::PlateSurface`].
+         * @enum {string}
+         */
+        PlateElementShape: "Auto" | "Triangle" | "Quad";
+        /** @description Division counts for a structured (u, v) mesh. */
+        PlateMeshDivisions: {
+            /** Format: int32 */
+            u: number;
+            /** Format: int32 */
+            v: number;
+        };
+        /**
+         * @description Meshing algorithm for a plate surface.
+         *
+         *     - `Auto`: solver chooses (currently Delaunay).
+         *     - `Structured`: transfinite quad grid; requires a 4-edge boundary and
+         *       [`PlateMeshDivisions`].
+         *     - `Unstructured`: force the Delaunay mesher.
+         * @enum {string}
+         */
+        PlateMeshMethod: "Auto" | "Structured" | "Unstructured";
+        /** @description Mesh generation settings for a plate surface. */
+        PlateMeshSettings: {
+            divisions?: null | components["schemas"]["PlateMeshDivisions"];
+            /** @default Auto */
+            element_shape: components["schemas"]["PlateElementShape"];
+            /** @default Auto */
+            method: components["schemas"]["PlateMeshMethod"];
+            /**
+             * Format: double
+             * @description Target element edge length. `None` meshes the boundary as-is (no interior
+             *     refinement).
+             */
+            target_size?: number | null;
+        };
+        /**
+         * @description A hole in a plate surface. The mesher generates elements around it; the
+         *     opening's boundary is part of the original surface geometry, not the elements.
+         */
+        PlateOpening: {
+            /** @description Hole boundary (≥ 3 existing model nodes). */
+            boundary_node_ids: number[];
+            /** Format: int32 */
+            id: number;
+        };
+        /**
+         * @description A pressure load applied directly to a modeled plate surface or a single
+         *     generated plate element. Distinct from [`super::surfaceload::SurfaceLoad`],
+         *     which applies a load over an arbitrary polygon.
+         */
+        PlatePressure: {
+            direction: components["schemas"]["Vector3"];
+            /** Format: int32 */
+            id: number;
+            /** Format: double */
+            magnitude: number;
+            /**
+             * @description When true the pressure acts on the area projected onto `direction`
+             *     (e.g. snow), otherwise on the true element area.
+             * @default false
+             */
+            projected: boolean;
+            /** @description What the pressure is applied to — exactly one of a surface or an element. */
+            target: components["schemas"]["PlatePressureTarget"];
+        };
+        /**
+         * @description The target of a [`PlatePressure`]. A tagged union so exactly one target kind
+         *     is set (replaces the previous pair of nullable ids).
+         */
+        PlatePressureTarget: {
+            /** @enum {string} */
+            kind: "Surface";
+            /** Format: int32 */
+            surface_id: number;
+        } | {
+            /** @enum {string} */
+            kind: "Element";
+            /** Format: int32 */
+            plate_element_id: number;
+        };
+        /** @description Per-plate-element result (stress resultants). */
+        PlateResult: {
+            centroid: components["schemas"]["NodeLocation"];
+            centroid_displacement_global: components["schemas"]["NodeDisplacement"];
+            centroid_displacement_local: components["schemas"]["NodeDisplacement"];
+            nodal_forces_global: {
+                [key: string]: components["schemas"]["NodeForces"];
+            };
+            /** Format: int32 */
+            plate_id: number;
+            resultants: components["schemas"]["PlateResultants"];
+        };
+        /** @description Plate stress resultants: membrane forces, bending moments and transverse shears. */
+        PlateResultants: {
+            /** Format: double */
+            mx: number;
+            /** Format: double */
+            mxy: number;
+            /** Format: double */
+            my: number;
+            /** Format: double */
+            nx: number;
+            /** Format: double */
+            nxy: number;
+            /** Format: double */
+            ny: number;
+            /** Format: double */
+            qx: number;
+            /** Format: double */
+            qy: number;
+        };
+        /**
+         * @description Optional per-plate stiffness scale factors (e.g. cracked-concrete, composite
+         *     or reduced-stiffness modeling). Each defaults to `1.0` (unmodified).
+         */
+        PlateStiffnessModifiers: {
+            /** Format: double */
+            bending?: number;
+            /** Format: double */
+            membrane?: number;
+            /** Format: double */
+            shear?: number;
+        };
+        /**
+         * @description A plate-element stress measure (FEM/plate checks).
+         * @enum {string}
+         */
+        PlateStressMeasure: "VonMises" | "PrincipalMax" | "PrincipalMin";
+        /**
+         * @description A user-modeled plate surface (slab / wall / panel) that is meshed into
+         *     [`super::plateelement::PlateElement`]s by the solver.
+         */
+        PlateSurface: {
+            /** @default Shell */
+            behavior: components["schemas"]["PlateBehavior"];
+            /** @description Outer boundary, referencing existing model nodes (counter-clockwise). */
+            boundary_node_ids: number[];
+            classification?: string | null;
+            /**
+             * @description Ids of the plate elements generated from this surface. Populated by the
+             *     mesher; any input value is ignored (derived from element
+             *     `source_surface_id`).
+             * @default []
+             */
+            readonly generated_plate_element_ids: number[];
+            /** Format: int32 */
+            id: number;
+            local_x_direction?: components["schemas"]["Vector3"];
+            /** Format: int32 */
+            material: number;
+            mesh?: null | components["schemas"]["PlateMeshSettings"];
+            /**
+             * Format: int32
+             * @description Surfaces sharing a `mesh_group_id` are meshed together so coincident
+             *     boundary nodes are shared between them.
+             */
+            mesh_group_id?: number | null;
+            name?: string | null;
+            /**
+             * Format: double
+             * @description Distance from the reference surface along the local plate normal.
+             * @default 0
+             */
+            offset: number;
+            /**
+             * @description Holes in the surface; the mesher generates elements around them.
+             * @default []
+             */
+            openings: components["schemas"]["PlateOpening"][];
+            /**
+             * @description In-plane constitutive assumption (plane stress/strain).
+             * @default PlaneStress
+             */
+            plane_state: components["schemas"]["PlaneState"];
+            stiffness_modifiers?: null | components["schemas"]["PlateStiffnessModifiers"];
+            /**
+             * @description Finite-element theory (thin/thick/auto).
+             * @default Auto
+             */
+            theory: components["schemas"]["PlateTheory"];
+            /** Format: double */
+            thickness: number;
+        };
+        /**
+         * @description Plate finite-element theory.
+         *
+         *     - `Kirchhoff`: thin-plate (no transverse shear deformation). Current default
+         *       formulation (DKT bending element).
+         *     - `Mindlin`: thick-plate (Reissner–Mindlin, includes transverse shear).
+         *     - `Auto`: the solver chooses based on span/thickness.
+         * @enum {string}
+         */
+        PlateTheory: "Auto" | "Mindlin" | "Kirchhoff";
+        /** @enum {string} */
+        PressureUnit: "Pa" | "kPa" | "MPa" | "GPa";
+        /** @description A bindable quantity — the source of a `{{variable}}` in a unity-check formula. */
+        QuantitySource: {
+            /**
+             * @description A local member force, reduced by `aggregation` and enveloped over the
+             *     check's applicable load combinations.
+             */
+            MemberForce: {
+                aggregation?: components["schemas"]["Aggregation"];
+                component: components["schemas"]["MemberForceComponent"];
+                of?: components["schemas"]["EntityTarget"];
+            };
+        } | {
+            /** @description A nodal displacement of the entity (member end / governing node). */
+            Displacement: {
+                component: components["schemas"]["DispComponent"];
+            };
+        } | {
+            /**
+             * @description Displacement (or rotation) of a node named relative to the entity — its own
+             *     ends, or the paired member/node via `reference_member` / `reference_node`.
+             *     Compose two of these for relative drift / differential settlement.
+             */
+            NodeDisplacement: {
+                at: components["schemas"]["EntityNodeRef"];
+                component: components["schemas"]["DispComponent"];
+            };
+        } | {
+            /**
+             * @description Deflected position (undeformed coordinate + displacement) of a node named
+             *     relative to the entity, along a global axis. For clearance / "below a line"
+             *     checks: compare two positions to get the deflected gap.
+             */
+            NodePosition: {
+                at: components["schemas"]["EntityNodeRef"];
+                axis: components["schemas"]["Axis"];
+            };
+        } | {
+            /**
+             * @description Transverse deflection relative to the entity's end-to-end chord
+             *     (support-to-support for a member-set). Removes support settlement and rigid
+             *     chord rotation, leaving the member's own sag — the quantity SLS deflection
+             *     limits (e.g. `span/200`) are written against. The deflected shape is
+             *     reconstructed by cubic Hermite interpolation and reduced by `aggregation`.
+             */
+            MemberDeflection: {
+                aggregation?: components["schemas"]["Aggregation"];
+                component: components["schemas"]["DeflectionComponent"];
+            };
+        } | {
+            /** @description A property of the entity's (or its reference member's) section. */
+            Section: {
+                of?: components["schemas"]["EntityTarget"];
+                property: components["schemas"]["SectionProperty"];
+            };
+        } | {
+            /** @description A property of the entity's (or its reference member's) material. */
+            Material: {
+                of?: components["schemas"]["EntityTarget"];
+                property: components["schemas"]["MaterialProperty"];
+            };
+        } | {
+            /** @description A geometric quantity of the entity (or its reference member). */
+            Geometry: {
+                of?: components["schemas"]["EntityTarget"];
+                property: components["schemas"]["GeometryProperty"];
+            };
+        } | {
+            /** @description A plate-element stress measure (for plate-targeted checks). */
+            PlateStress: {
+                measure: components["schemas"]["PlateStressMeasure"];
+            };
+        } | {
+            /**
+             * Format: double
+             * @description A literal, dimensionless constant — rendered raw (no unit, no scaling) in
+             *     the report trace. Use [`QuantitySource::DimensionedConstant`] instead when
+             *     the constant is compared against a dimensioned quantity (a moment capacity,
+             *     a deflection limit, …) so the trace stays unit-consistent.
+             */
+            Constant: number;
+        } | {
+            /**
+             * @description A literal constant tagged with its physical [`ConstantDimension`]. The
+             *     `value` is given in **SI** units for that dimension; the report trace then
+             *     scales and labels it exactly like the quantities it is compared against, so
+             *     the `substituted` arithmetic stays consistent with the computed value and
+             *     both sides of a demand/capacity ratio share a unit. (A moment capacity of
+             *     2 kN·m → `{ value: 2000.0, dimension: "Moment" }`.)
+             */
+            DimensionedConstant: {
+                dimension: components["schemas"]["ConstantDimension"];
+                /** Format: double */
+                value: number;
+            };
+        };
+        /** @description Support reaction at a node (forces, location and support id). */
+        ReactionNodeResult: {
+            location: components["schemas"]["NodeLocation"];
+            nodal_forces: components["schemas"]["NodeForces"];
+            /** Format: int32 */
+            support_id: number;
+        };
+        /**
+         * @description Design response spectrum definition. Externally tagged: exactly one of the
+         *     three variants.
+         */
+        ResponseSpectrum: {
+            /**
+             * @description EN 1998-1 parametric: shape parameters (S, Tb, Tc, Td) are looked up from
+             *     the ground type + spectrum type, scaled by `ag` and the behaviour factor
+             *     `q`.
+             */
+            EurocodeParametric: {
+                /**
+                 * Format: double
+                 * @description Design ground acceleration on type-A ground, `a_g = γ_I·a_gR` [m/s²].
+                 */
+                ag: number;
+                /**
+                 * Format: double
+                 * @description Lower-bound factor `β` for the design spectrum (default 0.2).
+                 */
+                beta?: number;
+                ground_type: components["schemas"]["GroundType"];
+                /**
+                 * Format: double
+                 * @description Behaviour factor `q` (≥ 1).
+                 */
+                q: number;
+                spectrum_type: components["schemas"]["SpectrumType"];
+            };
+        } | {
+            /** @description Direct spectrum parameters (no preset lookup); national-annex agnostic. */
+            DirectParameters: {
+                /** Format: double */
+                ag: number;
+                /** Format: double */
+                beta?: number;
+                /** Format: double */
+                q: number;
+                /** Format: double */
+                s: number;
+                /** Format: double */
+                tb: number;
+                /** Format: double */
+                tc: number;
+                /** Format: double */
+                td: number;
+            };
+        } | {
+            /**
+             * @description Arbitrary `(period, spectral_acceleration)` table [s, m/s²], linearly
+             *     interpolated (clamped beyond the ends).
+             */
+            CustomPoints: {
+                points: number[][];
+            };
+        };
+        ResultType: {
+            /** Format: int32 */
+            Loadcase: number;
+        } | {
+            /** Format: int32 */
+            Loadcombination: number;
+        };
+        /** @description Results for a single load case or combination: displacements, reactions, member and plate results. */
+        Results: {
+            displacement_nodes: {
+                [key: string]: components["schemas"]["NodeDisplacement"];
+            };
+            /**
+             * @description Solver diagnostics (errors/warnings) for this load case/combination.
+             *     Empty in the common case.
+             */
+            errors_and_warnings?: components["schemas"]["ErrorsAndWarnings"];
+            member_results: {
+                [key: string]: components["schemas"]["MemberResult"];
+            };
+            name: string;
+            plate_results?: {
+                [key: string]: components["schemas"]["PlateResult"];
+            };
+            reaction_nodes: {
+                [key: string]: components["schemas"]["ReactionNodeResult"];
+            };
+            result_type: components["schemas"]["ResultType"];
+            /**
+             * @description How the solve for this load case/combination ran (iterations, time,
+             *     convergence). See [`SolverDiagnostics`].
+             */
+            solver_diagnostics?: components["schemas"]["SolverDiagnostics"];
+            summary: components["schemas"]["ResultsSummary"];
+        };
+        /** @description All analysis results: per load case, per load combination, unity-check results and the optional HTML report. */
+        ResultsBundle: {
+            buckling?: null | components["schemas"]["BucklingResults"];
+            loadcases: {
+                [key: string]: components["schemas"]["Results"];
+            };
+            loadcombinations: {
+                [key: string]: components["schemas"]["Results"];
+            };
+            modal?: null | components["schemas"]["ModalResults"];
+            /**
+             * @description Optional single consolidated HTML report (populated only when requested
+             *     via the CLI `--report` flag or `AnalysisOptions.include_report_html`).
+             */
+            report_html?: string | null;
+            seismic?: null | components["schemas"]["SeismicResults"];
+            /**
+             * @description Unity-check results (one entry per check definition), enveloped over the
+             *     applicable load combinations.
+             * @default []
+             */
+            unity_check_results: components["schemas"]["UnityCheckResult"][];
+        };
+        /** @description Counts of the result quantities produced (displacements, reactions, member/plate forces). */
+        ResultsSummary: {
+            total_displacements: number;
+            total_member_forces: number;
+            total_plate_forces?: number;
+            total_reaction_forces: number;
+        };
+        /** @enum {string} */
+        RigidStrategy: "LinearMpc" | "RigidMember";
+        /** @description A cross-section: area, second moments, torsion/warping constants, shear areas, optional section moduli and EC3 design parameters. */
+        Section: {
+            /**
+             * Format: double
+             * @description Effective shear area in Y-direction (m²). None = no shear deformation (Euler-Bernoulli).
+             */
+            a_sy?: number | null;
+            /**
+             * Format: double
+             * @description Effective shear area in Z-direction (m²). None = no shear deformation (Euler-Bernoulli).
+             */
+            a_sz?: number | null;
+            /** Format: double */
+            area: number;
+            /** Format: double */
+            b?: number | null;
+            /**
+             * Format: double
+             * @description Centroid Y-coordinate within the shape path coordinate system (mm).
+             *     Used by the viewer to offset shape-path extrusions so the centroid
+             *     aligns with the member node.  Not used by the solver.
+             */
+            centroid_y?: number | null;
+            /**
+             * Format: double
+             * @description Centroid Z-coordinate within the shape path coordinate system (mm).
+             */
+            centroid_z?: number | null;
+            ec3?: null | components["schemas"]["Ec3SectionParams"];
+            /** Format: double */
+            h?: number | null;
+            /**
+             * Format: double
+             * @description Warping constant (m⁶). None = no warping (pure St. Venant torsion).
+             */
+            i_w?: number | null;
+            /** Format: double */
+            i_y: number;
+            /**
+             * Format: double
+             * @description Product of inertia about centroidal axes (mm⁴ in JSON, scaled to m⁴ by solver).
+             *     Non-zero for asymmetric sections (e.g. angle, C-channel with unequal flanges).
+             *     When present and non-zero, the solver auto-detects whether `i_y`/`i_z`
+             *     are centroidal or principal values (by checking angle consistency) and
+             *     applies or skips the principal-axis rotation accordingly.
+             */
+            i_yz?: number | null;
+            /** Format: double */
+            i_z: number;
+            /** Format: int32 */
+            id: number;
+            /** Format: double */
+            j: number;
+            /** Format: int32 */
+            material: number;
+            name: string;
+            /**
+             * Format: double
+             * @description Angle (degrees) from centroidal to principal axes.
+             *     When `i_yz` is absent or zero, this angle is used to rotate the
+             *     stiffness matrix from principal to centroidal frame.  When `i_yz`
+             *     is present, the solver checks whether `i_y`/`i_z` are centroidal
+             *     (angle matches formula) or principal (rotation applied).
+             *     Positive = counter-clockwise.  Default 0.
+             */
+            principal_axis_angle?: number | null;
+            /** Format: int32 */
+            shape_path?: number | null;
+            /**
+             * Format: double
+             * @description Wagner coefficient for lateral-torsional buckling.
+             */
+            wagner_coeff?: number | null;
+            /**
+             * Format: double
+             * @description Elastic section modulus about the y (major) axis (m³). Universal property
+             *     (≡ AISC `S_x`); used by unity checks for bending capacity.
+             */
+            wel_y?: number | null;
+            /**
+             * Format: double
+             * @description Elastic section modulus about the z (minor) axis (m³).
+             */
+            wel_z?: number | null;
+            /**
+             * Format: double
+             * @description Plastic section modulus about the y (major) axis (m³, ≡ AISC `Z_x`).
+             */
+            wpl_y?: number | null;
+            /**
+             * Format: double
+             * @description Plastic section modulus about the z (minor) axis (m³).
+             */
+            wpl_z?: number | null;
+            /**
+             * Format: double
+             * @description Shear center Y-coordinate relative to centroid (m).
+             */
+            y_s?: number | null;
+            /**
+             * Format: double
+             * @description Shear center Z-coordinate relative to centroid (m).
+             */
+            z_s?: number | null;
+        };
+        /** @description Forces at an intermediate cross-section along a member, in local member axes. */
+        SectionForce: {
+            /** @description Internal forces at this section, in the member local centroidal frame. */
+            forces: components["schemas"]["NodeForces"];
+            /**
+             * Format: double
+             * @description Fractional position along the member from the start node, in `[0, 1]`.
+             */
+            x_frac: number;
+        };
+        /**
+         * @description A section property (universal; see [`crate::models::members::section::Section`]).
+         * @enum {string}
+         */
+        SectionProperty: "Area" | "Iy" | "Iz" | "J" | "Iw" | "WelY" | "WelZ" | "WplY" | "WplZ" | "H" | "B" | "Asy" | "Asz";
+        /** @description Request for a seismic analysis (MRSA and/or lateral force). */
+        SeismicAnalysisSettings: {
+            /**
+             * Format: double
+             * @description Viscous damping ratio `ξ` for the CQC correlation (default 0.05).
+             * @default 0.05
+             */
+            damping: number;
+            /** @description Directional combination rule (default SRSS). */
+            directional_combination?: components["schemas"]["DirectionalCombination"];
+            /** @description Excitation directions to analyze (default `[X, Y]`). */
+            directions?: components["schemas"]["SeismicDirection"][];
+            /**
+             * @description Include structural self-mass (density·area + weight override) in the
+             *     seismic mass. Default true.
+             * @default true
+             */
+            include_structural_mass: boolean;
+            /** @description Structural mass-matrix formulation (Consistent default, Lumped optional). */
+            mass_formulation?: components["schemas"]["MassFormulation"];
+            /** @description Gravity load cases converted to seismic mass (`ΣG + ψE·Q`). */
+            mass_sources?: components["schemas"]["SeismicMassSource"][];
+            /**
+             * Format: int32
+             * @description Maximum subspace-iteration sweeps (default 100).
+             */
+            max_iterations?: number | null;
+            method: components["schemas"]["SeismicMethod"];
+            /** @description Modal combination rule (default CQC). */
+            modal_combination?: components["schemas"]["ModalCombination"];
+            /**
+             * Format: int32
+             * @description Number of vibration modes to extract for MRSA.
+             */
+            num_modes: number;
+            /** @description Design spectrum for the X excitation direction. */
+            spectrum_x: components["schemas"]["ResponseSpectrum"];
+            spectrum_y?: null | components["schemas"]["ResponseSpectrum"];
+            spectrum_z?: null | components["schemas"]["ResponseSpectrum"];
+            /**
+             * Format: double
+             * @description Eigen convergence tolerance (default 1e-6).
+             */
+            tolerance?: number | null;
+        };
+        /**
+         * @description A global excitation direction.
+         * @enum {string}
+         */
+        SeismicDirection: "X" | "Y" | "Z";
+        /** @description Seismic response for a single excitation direction. */
+        SeismicDirectionResult: {
+            /**
+             * Format: double
+             * @description Combined base shear in this direction (force units).
+             */
+            base_shear: number;
+            /** @description Combined response for this direction alone (before directional combination). */
+            combined: components["schemas"]["Results"];
+            direction: components["schemas"]["SeismicDirection"];
+            /** @description Per-mode contributions (empty for the lateral-force method). */
+            modes?: components["schemas"]["SeismicModeContribution"][];
+            /**
+             * Format: double
+             * @description Σ effective modal mass / total mass — the EN 1998-1 §4.3.3.3.1(3) ≥0.90
+             *     check (1.0 for the lateral-force method).
+             */
+            participating_mass_ratio: number;
+            /**
+             * Format: double
+             * @description Total seismic mass excited in this direction (kg).
+             */
+            total_seismic_mass: number;
+        };
+        /**
+         * @description A gravity load case that contributes to the seismic mass with a combination
+         *     factor (`ψE,i` for variable actions, `1.0` for permanent `G`).
+         */
+        SeismicMassSource: {
+            /** Format: int32 */
+            load_case_id: number;
+            /**
+             * Format: double
+             * @description Combination factor `ψE` (EN 1998-1 §3.2.4 / §4.2.4). Use 1.0 for permanent loads.
+             */
+            psi: number;
+        };
+        /**
+         * @description Which seismic method(s) to run.
+         * @enum {string}
+         */
+        SeismicMethod: "MODAL_RESPONSE_SPECTRUM" | "LATERAL_FORCE" | "BOTH";
+        /** @description A single mode's contribution to the response in one direction. */
+        SeismicModeContribution: {
+            /**
+             * Format: double
+             * @description Modal base shear `Γ²·Sd(T)` (force units).
+             */
+            base_shear: number;
+            /**
+             * Format: double
+             * @description Effective modal mass `Γ²` (kg).
+             */
+            effective_mass: number;
+            /**
+             * Format: double
+             * @description Effective modal mass / total seismic mass in this direction.
+             */
+            effective_mass_ratio: number;
+            /** Format: int32 */
+            mode: number;
+            /**
+             * Format: double
+             * @description Modal participation factor `Γ = φ̂ᵀ·M·r` for this direction (mass-normalized `φ̂`).
+             */
+            participation_factor: number;
+            /**
+             * Format: double
+             * @description Natural period `T = 2π/ω` (s).
+             */
+            period: number;
+            /**
+             * Format: double
+             * @description Design spectral acceleration `Sd(T)` (m/s²).
+             */
+            spectral_acceleration: number;
+        };
+        /**
+         * @description Seismic analysis results (EN 1998-1): modal response spectrum and/or
+         *     lateral-force outputs. Forces/displacements/reactions are in the model's
+         *     units; periods in seconds, spectral accelerations in m/s², masses in kg.
+         */
+        SeismicResults: {
+            lateral_force?: null | components["schemas"]["LateralForceResults"];
+            modal_response_spectrum?: null | components["schemas"]["MrsaResults"];
+        };
+        /** @description Top-level settings: general project info and the unit system. */
+        Settings: {
+            general_info: components["schemas"]["GeneralInfo"];
+            unit_settings: components["schemas"]["UnitSettings"];
+        };
+        /** @description A single command in a cross-section shape path (move/line/arc). */
+        ShapeCommand: {
+            /** Format: double */
+            center_y?: number | null;
+            /** Format: double */
+            center_z?: number | null;
+            command: components["schemas"]["PathCommand"];
+            /** Format: double */
+            r?: number | null;
+            /** Format: double */
+            theta0?: number | null;
+            /** Format: double */
+            theta1?: number | null;
+            /** Format: double */
+            y?: number | null;
+            /** Format: double */
+            z?: number | null;
+        };
+        /** @description A 2-D cross-section outline (a sequence of shape commands) used for visualization. */
+        ShapePath: {
+            /** Format: int32 */
+            id: number;
+            name: string;
+            shape_commands: components["schemas"]["ShapeCommand"][];
+        };
+        /**
+         * @description Per-result solver run diagnostics: how the solve for this load case /
+         *     combination actually ran. Populated best-effort; fields that are not
+         *     meaningful for a given solve path are left `None`.
+         */
+        SolverDiagnostics: {
+            /**
+             * @description Effective analysis method used for this result: `"Linear"`,
+             *     `"P_DELTA"`, or `"COROTATIONAL"`.
+             */
+            analysis_method?: string | null;
+            /** @description Whether the solve converged. Linear solves report `true`. */
+            converged?: boolean;
+            /**
+             * Format: int32
+             * @description Total nonlinear (Newton-Raphson / corotational) iterations actually
+             *     executed, summed across load steps and active-set/correction outer
+             *     loops. `None` for purely linear (first-order) solves.
+             */
+            iterations?: number | null;
+            /**
+             * Format: double
+             * @description Final relative residual norm at convergence (nonlinear solves). `None`
+             *     for linear solves where no residual is iterated.
+             */
+            residual_norm?: number | null;
+            /**
+             * Format: double
+             * @description Wall-clock solve time for this result, in milliseconds. `None` when the
+             *     time is not individually attributable (e.g. a batch first-order solve
+             *     that shares one factorization across many load cases).
+             */
+            solve_time_ms?: number | null;
+        };
+        /**
+         * @description A single solver diagnostic: a stable machine-readable `code` plus a
+         *     human-readable `message`. Severity is given by the list it belongs to
+         *     (`ErrorsAndWarnings::errors` vs `ErrorsAndWarnings::warnings`).
+         */
+        SolverMessage: {
+            code: string;
+            message: string;
+        };
+        /**
+         * @description EN 1998-1 spectrum type: Type 1 (Ms ≥ 5.5, Table 3.2) or Type 2 (Table 3.3).
+         * @enum {string}
+         */
+        SpectrumType: "TYPE1" | "TYPE2";
+        /** @description A single boundary condition (fixed/free/spring) with optional stiffness or stiffness curve. */
+        SupportCondition: {
+            condition_type: components["schemas"]["SupportConditionType"];
+            /** Format: double */
+            stiffness?: number | null;
+            stiffness_curve?: null | components["schemas"]["SupportStiffnessCurve"];
+        };
+        /** @enum {string} */
+        SupportConditionType: "Fixed" | "Free" | "Spring" | "PositiveOnly" | "NegativeOnly";
+        /**
+         * @description Which global reaction component a **support** stiffness curve depends on.
+         *
+         *     Supports react in the global coordinate system, so the names are the global
+         *     reaction components `Fx/Fy/Fz` (forces) and `Mx/My/Mz` (moments). Distinct
+         *     from [`MemberStiffnessCurveDriver`], whose member-local names (`N/Vy/Vz/…`)
+         *     apply to member-hinge stiffness curves.
+         * @enum {string}
+         */
+        SupportForceComponent: "Fx" | "Fy" | "Fz" | "Mx" | "My" | "Mz";
+        /**
+         * @description A **support** spring stiffness that varies with a global reaction component.
+         *
+         *     `points` is a sorted list of `[force_value, stiffness]` pairs and `depends_on`
+         *     is the global reaction component driving the interpolation.
+         */
+        SupportStiffnessCurve: {
+            /** @description Which global reaction component the stiffness depends on. */
+            depends_on: components["schemas"]["SupportForceComponent"];
+            /** @description Sorted `[force_value, stiffness]` pairs (≥ 2 points, positive stiffness). */
+            points: [
+                number,
+                number
+            ][];
+            /**
+             * @description When `true`, the curve is driven by the SIGNED reaction, so tension and
+             *     compression can have different stiffness (points may span negative
+             *     force). When `false` (default), the curve is driven by `|force|`
+             *     (symmetric — the legacy behaviour).
+             */
+            signed?: boolean;
+        };
+        /** @description A pressure load over an arbitrary polygon, distributed onto the underlying members/plates. */
+        SurfaceLoad: {
+            direction: components["schemas"]["Vector3"];
+            distribution_direction?: components["schemas"]["Vector3"];
+            /** Format: int32 */
+            id: number;
+            /** Format: double */
+            magnitude: number;
+            polygon: components["schemas"]["SurfaceLoadVertex"][];
+        };
+        /** @description A vertex of a surface-load polygon, in the **global** frame (`X`, `Y`, `Z`). */
+        SurfaceLoadVertex: {
+            /** Format: double */
+            X: number;
+            /** Format: double */
+            Y: number;
+            /** Format: double */
+            Z: number;
+        };
+        /**
+         * @description A geometric sway (out-of-plumb) imperfection, applied to the whole model as
+         *     imperfect initial geometry.
+         *
+         *     `magnitude` is the lean angle in **radians** about `axis`. Every node leans
+         *     toward the sway direction `axis × height_direction` by
+         *     `magnitude · (height above reference_point)`, where height is measured along
+         *     `height_direction`. The `height_direction` component is never displaced, so
+         *     nodes on the reference plane stay put (no base lift).
+         *
+         *     It applies to the entire model for the load combinations its
+         *     [`crate::models::imperfections::imperfectioncase::ImperfectionCase`] targets —
+         *     there is no per-member targeting; subdividing or grouping members does not
+         *     change the result.
+         */
+        SwayImperfection: {
+            /** @description Rotation axis. The sway direction is `axis × height_direction`. */
+            axis: components["schemas"]["Vector3"];
+            /**
+             * @description Direction along which height is measured and which is never displaced
+             *     (the structure's "up"). Defaults to global +Y.
+             */
+            height_direction?: components["schemas"]["Vector3"];
+            /**
+             * Format: double
+             * @description Sway (lean) angle in **radians**, applied about `axis`.
+             */
+            magnitude: number;
+            /**
+             * @description A point on the zero-sway plane: the lean is proportional to a node's
+             *     height above this point (along `height_direction`). Only a measurement
+             *     reference, not a pivot. Defaults to the origin.
+             */
+            reference_point?: components["schemas"]["Vector3"];
+        };
+        /** @description A translational geometric imperfection along an axis, applied to member sets. */
+        TranslationImperfection: {
+            axis: components["schemas"]["Vector3"];
+            /** Format: double */
+            magnitude: number;
+            memberset_ids: number[];
+        };
+        /** @description The model's unit system (length, force, density, pressure) for input and results. */
+        UnitSettings: {
+            /**
+             * @description Unit of every `Material.density`; independent of `lengthUnit`
+             *     (a mm/N model may still declare `"kg/m3"`). See [`DensityUnit`].
+             */
+            densityUnit?: components["schemas"]["DensityUnit"];
+            forceUnit?: components["schemas"]["ForceUnit"];
+            lengthUnit?: components["schemas"]["LengthUnit"];
+            pressureUnit?: components["schemas"]["PressureUnit"];
+            system?: components["schemas"]["UnitSystem"];
+        };
+        /**
+         * @description The unit system a model is expressed in.
+         * @enum {string}
+         */
+        UnitSystem: "metric" | "imperial";
+        /** @description One unity check the engineer defines. */
+        UnityCheckDefinition: {
+            applies_to: components["schemas"]["EntitySelector"];
+            description?: string | null;
+            id: string;
+            limit_state?: null | components["schemas"]["LimitState"];
+            /**
+             * @description Restrict to these combination ids (empty = all matching `limit_state`).
+             * @default []
+             */
+            load_combination_ids: number[];
+            name: string;
+            /**
+             * @description Optional narrative report template (authored HTML/markdown). Placeholders are
+             *     filled from each entity's computed trace: `{{label}}` → that step's display
+             *     string (number + unit) and `{{= expr}}` → `expr` evaluated over the trace
+             *     values (display units). Rendered into each `EntityUnityResult.rendered_report`
+             *     only when `analysis.options.render_unity_reports` is true.
+             */
+            report_template?: string | null;
+            spec: components["schemas"]["CheckSpec"];
+            /**
+             * @description Utilization colour boundaries [green→yellow, yellow→orange, orange→red].
+             * @default [
+             *       0.8,
+             *       0.95,
+             *       1
+             *     ]
+             */
+            thresholds: number[];
+        };
+        /** @description All entity results for one check + the governing (worst) one. */
+        UnityCheckResult: {
+            check_id: string;
+            governing?: null | components["schemas"]["EntityUnityResult"];
+            limit_state?: null | components["schemas"]["LimitState"];
+            /** Format: double */
+            max_utilization: number;
+            name: string;
+            /** @default [] */
+            per_entity: components["schemas"]["EntityUnityResult"][];
+            status: components["schemas"]["UnityStatus"];
+        };
+        /**
+         * @description 4-colour utilization status. Derived from utilization vs the check's
+         *     thresholds `[green→yellow, yellow→orange, orange→red]`.
+         * @enum {string}
+         */
+        UnityStatus: "Green" | "Yellow" | "Orange" | "Red";
+        /** @description Binds a friendly placeholder name (used in `{{name}}`) to a value source. */
+        VarBinding: {
+            name: string;
+            source: components["schemas"]["VarSource"];
+        };
+        /**
+         * @description The source of a named formula variable: a catalog quantity, or a
+         *     sub-expression over previously-declared variables/quantities.
+         */
+        VarSource: {
+            Quantity: components["schemas"]["QuantitySource"];
+        } | {
+            /** @description An expression string (may reference earlier variable names + functions). */
+            Expression: string;
+        };
+        /**
+         * @description A 3-component vector `[x, y, z]`.
+         *
+         *     Shared schema referenced (via `#[schema(value_type = Vector3)]`) by every
+         *     direction/axis field so the OpenAPI defines one reusable component instead of
+         *     repeating the inline array. The Rust model keeps plain `(f64, f64, f64)`
+         *     tuples and the JSON shape is unchanged.
+         */
+        Vector3: [
+            number,
+            number,
+            number
+        ];
+        /** @description A construction axis (origin + direction) for the UI/CAD workspace. */
+        WorkAxis: {
+            /** Format: double */
+            direction_x: number;
+            /** Format: double */
+            direction_y: number;
+            /** Format: double */
+            direction_z: number;
+            /** Format: int32 */
+            id: number;
+            name?: string;
+            /** Format: double */
+            origin_x: number;
+            /** Format: double */
+            origin_y: number;
+            /** Format: double */
+            origin_z: number;
+        };
+        /** @description A construction plane (origin + normal) for the UI/CAD workspace. */
+        WorkPlane: {
+            /** Format: int32 */
+            id: number;
+            name?: string;
+            /** Format: double */
+            normal_x: number;
+            /** Format: double */
+            normal_y: number;
+            /** Format: double */
+            normal_z: number;
+            /** Format: double */
+            origin_x: number;
+            /** Format: double */
+            origin_y: number;
+            /** Format: double */
+            origin_z: number;
+        };
+        /**
+         * @description Calculation-agnostic visualization / CAD helpers (not part of the structural
+         *     FE model, but useful for the UI and for grouping entities).
+         */
+        Workspace: {
+            /**
+             * @description Generic, calculation-agnostic entity groups for UI/visualization.
+             * @default []
+             */
+            entity_groups: components["schemas"]["EntityGroup"][];
+            /** @default [] */
+            work_axes: components["schemas"]["WorkAxis"][];
+            /** @default [] */
+            work_planes: components["schemas"]["WorkPlane"][];
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export type operations = Record<string, never>;
+
+export type FERS = components['schemas']['FERS'];
+export type ResultsBundle = components['schemas']['ResultsBundle'];