@graphite-sports/sdk 0.5.0 → 0.6.0

package/index.d.ts

@@ -10,6 +10,7 @@ import { FC } from 'react';
 import { FocusEventHandler } from 'react';
 import { HTMLInputTypeAttribute } from 'react';
 import { JSX } from 'react/jsx-runtime';
+import type { KeyboardEvent as KeyboardEvent_2 } from 'react';
 import { KeyboardEventHandler } from 'react';
 import { OnChangeFn } from '@tanstack/react-table';
 import { default as React_2 } from 'react';
@@ -32,6 +33,46 @@ import { TabPanels } from '@headlessui/react';
 import { toast } from 'react-hot-toast';
 import type { UnusedSkipTokenOptions } from '@tanstack/react-query';
 
+/**
+ * <C extends {}, P extends Primitive, S extends Sorted|Unsorted>(Table<C, S>, P) -> (Table<C & {<self.key>: P}, S>)
+ */
+declare interface AddColumnsNode {
+    columns: string[];
+}
+
+declare type AddGameEdit = Extract<LoweredFormatEdit, {
+    type: 'add-game';
+}>;
+
+declare type AddGameEdit_2 = {
+    type: 'add-game';
+    section: SectionId;
+    at: MoveTarget;
+} & ({
+    game: GameKind;
+    connectFrom?: ElementPortRef;
+    division?: never;
+} | {
+    game: Extract<GameKind, {
+        type: 'game-node';
+    }> & {
+        variant: {
+            type: 'parallel';
+        };
+    };
+    connectFrom: ElementPortRef;
+    division: GameDivision;
+});
+
+/**
+ * <#0 extends {}, #1>(#0, #1) -> (#0 & {<self.key>: #1})
+ */
+declare interface AddRecordFieldsNode {
+    fields: string[];
+}
+
+declare type AgeGroupClasses = Record<'female' | 'male', ClassId>;
+
 export declare type AnyQuerySchema = QuerySchema<QueryFields>;
 
 export declare function AppButton({ type, onClick, disabled: disabledProp, mutates, children, submit, className, loading, value, ref, href, autoFocus, }: AppButtonProps): JSX.Element;
@@ -48,7 +89,10 @@ export declare type AppButtonProps = {
     loading?: boolean;
     value?: string;
     ref?: RefObject<HTMLButtonElement | null>;
-    /** Focuses the button on mount, and with `href` also when this turns true later. */
+    /**
+     * Focuses the button as soon as it is enabled while this is set, which can be after mount, unless a text field has the
+     * focus. Again only after this was false.
+     */
     autoFocus?: boolean;
     /** Makes the button a link to this route, so it can also be opened in a new tab. `onClick` runs before routing. */
     href?: string;
@@ -97,6 +141,8 @@ export declare type AppInputProps = {
     onFocus?: FocusEventHandler<HTMLInputElement>;
     onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
     type?: HTMLInputTypeAttribute;
+    min?: number;
+    step?: number;
     placeholder?: string;
     required?: boolean;
     maxLength?: number;
@@ -169,7 +215,7 @@ export declare function AppTab({ className, ...props }: ComponentProps<typeof Ta
 
 export declare function AppTabGroup(props: ComponentProps<typeof TabGroup>): JSX.Element;
 
-export declare function AppTable<TData extends RowData>({ data, columns, actions, allowSelect, getRowId, getRowState, rowClicked, rowHref, initialPageSize, initialSorting, pageSizes, enableSorting, autoResetPageIndex, emptyTableText, columnVisibility: columnVisibilityState, }: TableProps<TData>): JSX.Element;
+export declare function AppTable<TData extends RowData>({ data, columns, actions, allowSelect, getRowId, getRowState, getRowClassName, rowClicked, rowHref, initialPageSize, initialSorting, pageSizes, enableSorting, autoResetPageIndex, emptyTableText, columnVisibility: columnVisibilityState, enableSearch, }: TableProps<TData>): JSX.Element;
 
 export declare type AppTableFeatures = typeof appTableFeatures;
 
@@ -224,11 +270,14 @@ export declare type ArrayValue<T = Primitive> = Value<T>[];
 
 export declare type BIB = Brand<number, 'bib'>;
 
+declare type BooleanOp = "and" | "or" | "xor" | "not";
+
 /**
- * Mirrors the backend's `domain_id!` newtype IDs (graphite-engine/src/domain_id.rs) so distinct ID
- * kinds can't be mixed up on the frontend either. Every type here must match the name of a
- * `#/components/schemas/<Name>` entry in the OpenAPI schema - see the `DOMAIN_ID_NAMES` redirect in
- * generate-openapi-types.js, which points the generated schema types at these instead of `number`/`string`.
+ * Mirrors the backend's `domain_id!` newtype IDs so distinct ID kinds can't be mixed up on the frontend either. Every
+ * type here must match the name of a `#/components/schemas/<Name>` entry in the OpenAPI schema - see the
+ * `DOMAIN_ID_NAMES` redirect in generate-openapi-types.js, which points the generated schema types at these instead of
+ * `number`/`string`. The ids graphite-wasm exports (EventId, FormatId, ...) are not here: they come from
+ * graphite_wasm.d.ts, branded the same way.
  */
 export declare type Brand<T, B> = T & {
     readonly __brand: B;
@@ -237,13 +286,15 @@ export declare type Brand<T, B> = T & {
 /** Stable reference — a new inline `select` on every `queryOptions()` call makes React Query re-select each render. */
 export declare function buildCompetitorsMapped(competitors: CompetitorDAO[]): CompetitorsMapped;
 
-export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspaceId" | "/workspace/:workspaceId/event/:eventId" | "/download" | "/login" | "/register" | "/preferences" | "/crate-workspace" | "/workspace/:workspaceId/create-event" | "/workspace/:workspaceId/event/:eventId/dashboard" | "/workspace/:workspaceId/event/:eventId/create-class" | "/workspace/:workspaceId/event/:eventId/class/:classId" | "/workspace/:workspaceId/event/:eventId/create-competitor" | "/workspace/:workspaceId/event/:eventId/create-team" | "/workspace/:workspaceId/event/:eventId/competitor/:competitorId" | "/workspace/:workspaceId/event/:eventId/create-format" | "/workspace/:workspaceId/event/:eventId/format/:formatId" | "/workspace/:workspaceId/event/:eventId/format/:formatId/tests" | "/workspace/:workspaceId/event/:eventId/format/:formatId/tests/:formatTestId" | "/workspace/:workspaceId/event/:eventId/graph" | "/workspace/:workspaceId/event/:eventId/lineage" | "/workspace/:workspaceId/event/:eventId/create-game" | "/workspace/:workspaceId/event/:eventId/game/:gameId" | "/workspace/:workspaceId/event/:eventId/table/:tableId" | "/workspace/:workspaceId/event/:eventId/create-game-format" | "/workspace/:workspaceId/event/:eventId/game-format/:gameFormatId" | "/workspace/:workspaceId/event/:eventId/create-template" | "/workspace/:workspaceId/event/:eventId/template/:templateId" | "/workspace/:workspaceId/event/:eventId/extension/$extensionIdentifier">(path: Path, params: PathParams<Path>, ...query: {
+export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspaceId" | "/workspace/:workspaceId/event/:eventId" | "/login" | "/register" | "/download" | "/preferences" | "/crate-workspace" | "/workspace/:workspaceId/create-event" | "/workspace/:workspaceId/event/:eventId/dashboard" | "/workspace/:workspaceId/event/:eventId/create-class" | "/workspace/:workspaceId/event/:eventId/class/:classId" | "/workspace/:workspaceId/event/:eventId/create-competitor" | "/workspace/:workspaceId/event/:eventId/create-team" | "/workspace/:workspaceId/event/:eventId/competitor/:competitorId" | "/workspace/:workspaceId/event/:eventId/create-format" | "/workspace/:workspaceId/event/:eventId/format/:formatId" | "/workspace/:workspaceId/event/:eventId/format/:formatId/tests" | "/workspace/:workspaceId/event/:eventId/format/:formatId/tests/:formatTestId" | "/workspace/:workspaceId/event/:eventId/graph" | "/workspace/:workspaceId/event/:eventId/simplified" | "/workspace/:workspaceId/event/:eventId/lineage" | "/workspace/:workspaceId/event/:eventId/create-game" | "/workspace/:workspaceId/event/:eventId/game/:gameId" | "/workspace/:workspaceId/event/:eventId/create-table" | "/workspace/:workspaceId/event/:eventId/table/:tableId" | "/workspace/:workspaceId/event/:eventId/create-game-format" | "/workspace/:workspaceId/event/:eventId/game-format/:gameFormatId" | "/workspace/:workspaceId/event/:eventId/create-template" | "/workspace/:workspaceId/event/:eventId/template/:templateId" | "/workspace/:workspaceId/event/:eventId/extension/$extensionIdentifier">(path: Path, params: PathParams<Path>, ...query: {
     '/': undefined;
     '/download': undefined;
     '/login': QuerySchema<    {
     readonly returnTo: OptionalQueryField<ReturnPath>;
     }>;
-    '/register': undefined;
+    '/register': QuerySchema<    {
+    readonly returnTo: OptionalQueryField<ReturnPath>;
+    }>;
     '/preferences': undefined;
     '/crate-workspace': undefined;
     '/workspace/:workspaceId': undefined;
@@ -256,6 +307,9 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     '/workspace/:workspaceId/event/:eventId/create-team': undefined;
     '/workspace/:workspaceId/event/:eventId/competitor/:competitorId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-format': QuerySchema<    {
+    readonly name: OptionalQueryField<string>;
+    readonly template: OptionalQueryField<FormatId>;
+    readonly place: OptionalQueryField<GamePlace>;
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
     readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
     }>;
@@ -268,6 +322,12 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     '/workspace/:workspaceId/event/:eventId/graph': QuerySchema<    {
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
     }>;
+    '/workspace/:workspaceId/event/:eventId/simplified': QuerySchema<    {
+    /** Applied once, e.g. for a format just created to be used as a game. */
+    readonly addGame: OptionalQueryField<AddGameEdit>;
+    readonly focusNode: RepeatedQueryField<FormatNodeId>;
+    readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
+    }>;
     '/workspace/:workspaceId/event/:eventId/lineage': QuerySchema<    {
     readonly game: OptionalQueryField<GameId>;
     readonly table: OptionalQueryField<TableId>;
@@ -280,6 +340,7 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     }>;
     '/workspace/:workspaceId/event/:eventId/create-game': undefined;
     '/workspace/:workspaceId/event/:eventId/game/:gameId': undefined;
+    '/workspace/:workspaceId/event/:eventId/create-table': undefined;
     '/workspace/:workspaceId/event/:eventId/table/:tableId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-game-format': undefined;
     '/workspace/:workspaceId/event/:eventId/game-format/:gameFormatId': undefined;
@@ -293,7 +354,9 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     '/login': QuerySchema<    {
     readonly returnTo: OptionalQueryField<ReturnPath>;
     }>;
-    '/register': undefined;
+    '/register': QuerySchema<    {
+    readonly returnTo: OptionalQueryField<ReturnPath>;
+    }>;
     '/preferences': undefined;
     '/crate-workspace': undefined;
     '/workspace/:workspaceId': undefined;
@@ -306,6 +369,9 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     '/workspace/:workspaceId/event/:eventId/create-team': undefined;
     '/workspace/:workspaceId/event/:eventId/competitor/:competitorId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-format': QuerySchema<    {
+    readonly name: OptionalQueryField<string>;
+    readonly template: OptionalQueryField<FormatId>;
+    readonly place: OptionalQueryField<GamePlace>;
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
     readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
     }>;
@@ -318,6 +384,12 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     '/workspace/:workspaceId/event/:eventId/graph': QuerySchema<    {
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
     }>;
+    '/workspace/:workspaceId/event/:eventId/simplified': QuerySchema<    {
+    /** Applied once, e.g. for a format just created to be used as a game. */
+    readonly addGame: OptionalQueryField<AddGameEdit>;
+    readonly focusNode: RepeatedQueryField<FormatNodeId>;
+    readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
+    }>;
     '/workspace/:workspaceId/event/:eventId/lineage': QuerySchema<    {
     readonly game: OptionalQueryField<GameId>;
     readonly table: OptionalQueryField<TableId>;
@@ -330,6 +402,7 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     }>;
     '/workspace/:workspaceId/event/:eventId/create-game': undefined;
     '/workspace/:workspaceId/event/:eventId/game/:gameId': undefined;
+    '/workspace/:workspaceId/event/:eventId/create-table': undefined;
     '/workspace/:workspaceId/event/:eventId/table/:tableId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-game-format': undefined;
     '/workspace/:workspaceId/event/:eventId/game-format/:gameFormatId': undefined;
@@ -339,9 +412,27 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     '*': undefined;
 }[Path] ? T extends AnyQuerySchema ? [query?: QueryInput<T> | undefined] : [] : never : never) => string;
 
+/** How to handle a disqualification: one of the strategies to catch it, or "throw" - not catching it at all. */
+declare type CatchDqChoice = DqStrategy_2 | 'throw';
+
+declare type ChildrenSpec = { type: "disallowed" } | { type: "allowed" } | { type: "closure"; signature: NodeSignature<Type> };
+
 export declare type ClassDAO = components['schemas']['ClassDAO'];
 
-export declare type ClassId = Brand<string, 'classId'>;
+/**
+ * Outputs the competitors of classes as a table.
+ *
+ * ```text
+ * multiple: ('roundrobin' | 'serpentine' | 'concat', ...Class) -> (Table<{}, Sorted>)
+ * ```
+ */
+declare type ClassesCompetitorsNode = null;
+
+/**
+ * Identifies a class. Random ([Self::new_random]) from the endpoint, or derived by `ImportArchiveMutation`.
+ * Deserializing one only yields a reference to an existing class; it does not check that it exists.
+ */
+export declare type ClassId = string & { readonly __brand: 'classId' };
 
 export declare type ClassResponse = components['schemas']['ClassResponse'];
 
@@ -349,6 +440,8 @@ declare type CommonApiKeyId = Brand<number, 'commonApiKeyId'>;
 
 export declare type CommonWorkspaceId = WorkspaceRootId | WorkspaceSelfHostedId;
 
+declare type ComparisonOp = "greater" | "less" | "greater-equals" | "less-equals" | "equals" | "not-equals";
+
 export declare type CompetitorDAO = components['schemas']['CompetitorDAO'];
 
 export declare type CompetitorId = Brand<number, 'competitorId'>;
@@ -361,6 +454,22 @@ export declare const CompetitorNameLineSpacer: FC<{
     className?: string;
 }>;
 
+/**
+ * Two rows of the same competitor met in one table.
+ */
+declare interface CompetitorNotUniqueError {
+    competitorId: number;
+    /**
+     * Where the row that came first comes from, see [crate::Origin::trails]. The steps of the node that failed are not
+     * attributed yet.
+     */
+    first: Trail[];
+    /**
+     * Where the row that clashed with it comes from.
+     */
+    second: Trail[];
+}
+
 /**
  * Shows which competitor is picked and lets the user pick another one.
  */
@@ -385,11 +494,14 @@ export declare type CompetitorSelectorProps<IsRequired extends boolean = false>
 
 export declare interface CompetitorsMapped {
     byId: Map<CompetitorId, CompetitorDAO>;
+    /** Leaves out the competitors without a bib. */
     byBib: Map<BIB, CompetitorDAO>;
 }
 
 export declare type CompetitorType = components['schemas']['CompetitorType'];
 
+declare type CompetitorType_2 = "individual" | "team";
+
 declare interface components {
     schemas: {
         APIKeyPathVariables: {
@@ -418,9 +530,7 @@ declare interface components {
             eventId: components["schemas"]["EventId"];
         };
         /** @description <C extends {}, P extends Primitive, S extends Sorted|Unsorted>(Table<C, S>, P) -> (Table<C & {<self.key>: P}, S>) */
-        AddColumnsNode: {
-            columns: string[];
-        };
+        AddColumnsNode: AddColumnsNode;
         AddCompetitorsMutation: {
             competitorDtos: components["schemas"]["CompetitorDTO"][];
             competitorType: components["schemas"]["CompetitorType"];
@@ -475,9 +585,7 @@ declare interface components {
             variant: components["schemas"]["TableVariant"];
         };
         /** @description <#0 extends {}, #1>(#0, #1) -> (#0 & {<self.key>: #1}) */
-        AddRecordFieldsNode: {
-            fields: string[];
-        };
+        AddRecordFieldsNode: AddRecordFieldsNode;
         AddTarget: {
             backendUrl: string;
             /** @description Replicate into this existing remote workspace instead of creating a new one. */
@@ -580,9 +688,9 @@ declare interface components {
             type: "group";
         };
         /** @enum {string} */
-        ArithmeticOperator: "add" | "subtract";
+        ArithmeticOperator: ArithmeticOperator;
         ArrayValue_for_Primitive: ArrayValue<Primitive>;
-        ArrayValue_for_SerializableNonPrimitiveValue: components["schemas"]["Value_for_SerializableNonPrimitiveValue"][];
+        ArrayValue_for_SerializableNonPrimitiveValue: ArrayValue<SerializableNonPrimitiveValue>;
         AuthScope: {
             /** @constant */
             type: "general";
@@ -607,28 +715,10 @@ declare interface components {
         BIB: BIB;
         BibNotUniqueError: components["schemas"]["BIB"];
         /** @enum {string} */
-        BooleanOp: "and" | "or" | "xor" | "not";
-        CatchDqNode: {
-            /**
-             * @description The node has one output per catch key, in order. The strategy decides how multiple
-             *      caught tables of the same key get merged.
-             */
-            catches: {
-                [key: string]: components["schemas"]["MultiplexingStrategy"];
-            };
-        };
-        ChildrenSpec: {
-            /** @constant */
-            type: "disallowed";
-        } | {
-            /** @constant */
-            type: "allowed";
-        } | {
-            /** @constant */
-            type: "closure";
-            /** @description The signature that the inner closure must adhere to. */
-            signature: components["schemas"]["NodeSignature_for_Type_and_ParamRef"];
-        };
+        BooleanOp: BooleanOp;
+        /** @description The [CICManagedState] of a relation that is a membership, so all but `DeletedByUser`. */
+        CICMembershipState: "added-by-user" | "automation";
+        ChildrenSpec: ChildrenSpec;
         ClassAutomationDTO: {
             /** @constant */
             type: "age";
@@ -661,7 +751,7 @@ declare interface components {
         ClassAutomationScriptError: {
             /** @constant */
             type: "parse-error";
-            data: components["schemas"]["ParseError"];
+            data: components["schemas"]["ExpressionParseError"];
         } | {
             /** @constant */
             type: "type-errors";
@@ -676,6 +766,9 @@ declare interface components {
             attributes: components["schemas"]["RecordValue_for_Primitive"];
             automationScript?: components["schemas"]["ClassAutomationScript"] | null;
             automationScriptError?: components["schemas"]["ClassAutomationScriptError"] | null;
+            customData: {
+                [key: string]: string;
+            };
             eventId: components["schemas"]["EventId"];
             gender: components["schemas"]["ClassGender"];
             id: components["schemas"]["ClassId"];
@@ -689,6 +782,9 @@ declare interface components {
             description: string;
             attributes: components["schemas"]["RecordValue_for_Primitive"];
             automation?: components["schemas"]["ClassAutomationDTO"] | null;
+            customData?: {
+                [key: string]: string;
+            };
             gender: components["schemas"]["ClassGender"];
             name: string;
             state: components["schemas"]["TableState"];
@@ -743,19 +839,27 @@ declare interface components {
          *      multiple: ('roundrobin' | 'serpentine' | 'concat', ...Class) -> (Table<{}, Sorted>)
          *      ```
          */
-        ClassesCompetitorsNode: null;
+        ClassesCompetitorsNode: ClassesCompetitorsNode;
         /** Format: int64 */
         CommonApiKeyId: CommonApiKeyId;
-        /** Format: int64 */
         CommonWorkspaceId: CommonWorkspaceId;
         /** @enum {string} */
-        ComparisonOp: "greater" | "less" | "greater-equals" | "less-equals" | "equals" | "not-equals";
+        ComparisonOp: ComparisonOp;
         CompetitorDAO: {
             attributes: components["schemas"]["RecordValue_for_Primitive"];
-            bib: components["schemas"]["BIB"];
+            /** @description Unique among the competitors of the event that have one. */
+            bib?: components["schemas"]["BIB"] | null;
             birthdate?: string | null;
             /** @description The competitor_type MUST NEVER be altered after creation. */
             competitorType: components["schemas"]["CompetitorType"];
+            customData: {
+                [key: string]: string;
+            };
+            /**
+             * @description Nodes that bring the competitors of the event into the graph (event competitors, classes) leave disabled
+             *      competitors out, everything else treats them as usual.
+             */
+            enabled: boolean;
             eventId: components["schemas"]["EventId"];
             firstName?: string | null;
             /** @description Genders are `"f"`, `"m"`, or any other string stored in SQLite. */
@@ -768,8 +872,14 @@ declare interface components {
         };
         CompetitorDTO: {
             attributes: components["schemas"]["RecordValue_for_Primitive"];
-            bib: components["schemas"]["BIB"];
+            /** @description See [CompetitorDAO::bib]. */
+            bib?: components["schemas"]["BIB"] | null;
             birthdate?: string | null;
+            customData?: {
+                [key: string]: string;
+            };
+            /** @description See [CompetitorDAO::enabled]. Missing means enabled. */
+            enabled?: boolean;
             firstName?: string | null;
             gender?: components["schemas"]["Gender"] | null;
             lastName?: string | null;
@@ -785,6 +895,7 @@ declare interface components {
         CompetitorInClassDTO: {
             classId: components["schemas"]["ClassId"];
             competitorId: components["schemas"]["CompetitorId"];
+            managedState: components["schemas"]["CICMembershipState"];
             /** Format: int64 */
             place: number;
         };
@@ -795,15 +906,15 @@ declare interface components {
             teamId: components["schemas"]["CompetitorId"];
             to?: string | null;
         };
-        /** Format: int64 */
-        CompetitorNotUniqueError: number;
+        /** @description Two rows of the same competitor met in one table. */
+        CompetitorNotUniqueError: CompetitorNotUniqueError;
         CompetitorPathVariables_for_CommonWorkspaceId: {
             competitorId: components["schemas"]["CompetitorId"];
             eventId: components["schemas"]["EventId"];
             workspaceId: components["schemas"]["CommonWorkspaceId"];
         };
         /** @enum {string} */
-        CompetitorType: "individual" | "team";
+        CompetitorType: CompetitorType_2;
         CompetitorTypeQuery: {
             competitorType: components["schemas"]["CompetitorType"];
         };
@@ -878,14 +989,7 @@ declare interface components {
          *      Besides the infer keyword, works almost exactly like conditional types in typescript.
          *      Checkout [this doc](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) for a good guide on the ts conditionals.
          */
-        Conditional_for_Type_and_ErasedScopedTypeRef_for_Type: {
-            /** @description @todo */
-            infer: components["schemas"]["LocalParamID"][];
-            tElse: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-            tTest: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-            tTestBound: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-            tThen: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-        };
+        Conditional_for_Type_and_ErasedScopedTypeRef_for_Type: Conditional<Type, components["schemas"]["ErasedScopedTypeRef_for_Type"]>;
         /**
          * @description Represents the following: `t_test` extends `t_test_bound` ? `t_then` : `t_else`
          *      Besides the infer keyword, works almost exactly like conditional types in typescript.
@@ -912,12 +1016,7 @@ declare interface components {
             data: string;
         };
         /** @description A pin that reroutes a connection */
-        ConnectionPin: {
-            /** Format: int64 */
-            x: number;
-            /** Format: int64 */
-            y: number;
-        };
+        ConnectionPin: ConnectionPin;
         /** @description Contact information for the exposed API. */
         Contact: {
             /**
@@ -982,6 +1081,52 @@ declare interface components {
         };
         /** @enum {string} */
         CustomControl: "sort-criterion";
+        CustomDataEntity: {
+            /** @constant */
+            type: "game";
+            id: components["schemas"]["GameId"];
+        } | {
+            /** @constant */
+            type: "game-format";
+            id: components["schemas"]["GameFormatId"];
+        } | {
+            /** @constant */
+            type: "format";
+            id: components["schemas"]["FormatId"];
+        } | {
+            /** @constant */
+            type: "event";
+            id: components["schemas"]["EventId"];
+        } | {
+            /** @constant */
+            type: "competitor";
+            id: components["schemas"]["CompetitorId"];
+        } | {
+            /** @constant */
+            type: "class";
+            id: components["schemas"]["ClassId"];
+        } | {
+            /** @constant */
+            type: "format-group";
+            id: components["schemas"]["FormatGroupId"];
+        } | {
+            /** @constant */
+            type: "format-node";
+            id: components["schemas"]["FormatNodeId"];
+        };
+        /**
+         * @description Auto-generated discriminant enum variants
+         * @enum {string}
+         */
+        CustomDataEntityType: "game" | "game-format" | "format" | "event" | "competitor" | "class" | "format-group" | "format-node";
+        CustomDataPathVariables_for_CommonWorkspaceId: {
+            entity: components["schemas"]["CustomDataEntityType"];
+            eventId: components["schemas"]["EventId"];
+            /** @description The id of the entity, which belongs to the event of the path. For `event`, the id of that event. */
+            id: string;
+            key: string;
+            workspaceId: components["schemas"]["CommonWorkspaceId"];
+        };
         DayAndMonth: {
             /**
              * Format: uint8
@@ -1212,11 +1357,9 @@ declare interface components {
         DetailedSupertypeDiagnostics_for_Type: DetailedSupertypeDiagnostics<Type>;
         /**
          * @description Disqualifies every row of the table it receives, throwing them all under `key` so that a
-         *      [`CatchDqNode`](super::catch_dq_node::CatchDqNode) further up the graph can collect them.
+         *      [`GroupNode`](super::group_node::GroupNode) further up the graph can collect them.
          */
-        DisqualifyNode: {
-            key: components["schemas"]["DqKey"];
-        };
+        DisqualifyNode: DisqualifyNode;
         /** @description The rows of one side after the common row. */
         DivergedRows: {
             /** Format: int64 */
@@ -1230,9 +1373,13 @@ declare interface components {
             source: components["schemas"]["DivergedRows"];
             target: components["schemas"]["DivergedRows"];
         };
-        DqKey: string;
+        /** @description What a node does by default with a disqualification it can throw. */
+        DqDefaultStrategy: DqDefaultStrategy;
+        DqKey: DqKey;
+        /** @description What a format or game format says about one of its disqualification kinds. */
+        DqSettings: DqSettings;
         /** @description Decides how caught disqualifications are surfaced. */
-        DqStrategy: "output-placed" | "output-unplaced" | "append-placed" | "append-unplaced";
+        DqStrategy: DqStrategy;
         /**
          * @description How functions that combine tables from multiple competitor sources (e.g. merging or
          *      concatenating) should treat a competitor that appears in more than one of them.
@@ -1377,27 +1524,14 @@ declare interface components {
         /** @description Auto-generated discriminant enum variants */
         EntityChangeEventDiscriminants: ("Event" | "Game" | "Table" | "GameFormat" | "FormatGroup" | "Row" | "RowMutation" | "FormatNode" | "Format" | "Class" | "Extension" | "Competitor" | "FormatTest" | "Log" | "ContentInEventFolder") | "CompetitorInTeam" | "CompetitorInClass";
         /** @description A scope portal that used to be there but got removed in order to be serializable */
-        ErasedScopedTypeRef_for_Type: {
-            /** @constant */
-            type: "Param";
-            data: components["schemas"]["ParamRef"];
-        } | {
-            /** @constant */
-            type: "ScopedExpr";
-            data: {
-                expr: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-            };
-        };
-        EventCompetitorsNode: components["schemas"]["CompetitorType"];
+        ErasedScopedTypeRef_for_Type: ErasedScopedTypeRef<Type>;
+        EventCompetitorsNode: EventCompetitorsNode;
         EventDAO: {
             description: string;
             attributes: components["schemas"]["RecordValue_for_Primitive"];
-            /**
-             * @description Whether nodes that combine tables from multiple competitor sources (e.g. merging or
-             *      concatenating) should error or silently drop rows when they encounter the same competitor
-             *      more than once.
-             */
-            duplicateCompetitorPolicy: components["schemas"]["DuplicateCompetitorPolicy"];
+            customData: {
+                [key: string]: string;
+            };
             /** Format: date */
             endDate?: string | null;
             id: components["schemas"]["EventId"];
@@ -1409,37 +1543,38 @@ declare interface components {
              *      action should always be to create and set the root format.
              */
             rootFormatId?: components["schemas"]["FormatId"] | null;
+            settings: components["schemas"]["EventSettings"];
             /**
              * Format: date
              * @description Updating this requires updating classes as well.
              */
             startDate: string;
             teamCompetitorTypes: components["schemas"]["RecordTypeWithDefaults"];
-            /** @description Enables tooling for trying out an event with generated data. */
-            testMode: boolean;
         };
         EventDTO: {
             /** @default  */
             description: string;
             attributes: components["schemas"]["RecordValue_for_Primitive"];
             /**
-             * @description Whether nodes that combine tables from multiple competitor sources (e.g. merging or
-             *      concatenating) should error or silently drop rows when they encounter the same competitor
-             *      more than once.
-             * @default error
+             * @description The key `ui:test-mode` ([TEST_MODE_KEY]) set to `"true"` enables tooling for trying out the event with
+             *      generated data.
              */
-            duplicateCompetitorPolicy: components["schemas"]["DuplicateCompetitorPolicy"];
+            customData?: {
+                [key: string]: string;
+            };
             endDate?: string | null;
             individualCompetitorTypes: components["schemas"]["RecordTypeWithDefaults"];
             name: string;
+            /**
+             * @default {
+             *       "duplicateCompetitorPolicy": "error",
+             *       "invalidLinkedFormatPolicy": "last-known-table"
+             *     }
+             */
+            settings: components["schemas"]["EventSettings"];
             /** @description The start date might be used for calculating the competitors age. */
             startDate: string;
             teamCompetitorTypes: components["schemas"]["RecordTypeWithDefaults"];
-            /**
-             * @description Enables tooling for trying out an event with generated data.
-             * @default false
-             */
-            testMode: boolean;
         };
         /**
          * Format: uuid
@@ -1534,6 +1669,21 @@ declare interface components {
             rows: components["schemas"]["EventLineageRow"][];
             tableId: components["schemas"]["TableId"];
         };
+        /** @description Settings of an event that change how its formats execute. Missing fields get their defaults. */
+        EventSettings: {
+            /**
+             * @description Whether nodes that combine tables from multiple competitor sources (e.g. merging or
+             *      concatenating) should error or silently drop rows when they encounter the same competitor
+             *      more than once.
+             * @default error
+             */
+            duplicateCompetitorPolicy: components["schemas"]["DuplicateCompetitorPolicy"];
+            /**
+             * @description What an InputTableNode returns when the format of its linked result table node is invalid.
+             * @default last-known-table
+             */
+            invalidLinkedFormatPolicy: components["schemas"]["InvalidLinkedFormatPolicy"];
+        };
         Example: {
             /**
              * @description Long description for the example.
@@ -1560,6 +1710,10 @@ declare interface components {
         } & {
             [key: string]: unknown;
         };
+        ExpressionParseError: {
+            kind: components["schemas"]["ParseErrorKind"];
+            location: components["schemas"]["SourceLocation"];
+        };
         ExtensionChangeEvent: ({
             /** @constant */
             type: "added";
@@ -1625,18 +1779,7 @@ declare interface components {
         } & {
             [key: string]: unknown;
         };
-        ExtractRecordFieldError_for_Primitive: {
-            /** @constant */
-            type: "field-does-not-exist";
-            data: string;
-        } | {
-            /** @constant */
-            type: "invalid-type";
-            data: {
-                field: string;
-                value?: components["schemas"]["Value_for_Primitive"] | null;
-            };
-        };
+        ExtractRecordFieldError_for_Primitive: ExtractRecordFieldError<Primitive>;
         FieldTypeWithDefault: FieldTypeWithDefault;
         FolderContent: {
             classIds: components["schemas"]["ClassId"][];
@@ -1652,18 +1795,22 @@ declare interface components {
             data: components["schemas"]["GameWithTables"];
         });
         FolderPath: string[];
-        FormatConnectionDTO: {
-            pins: components["schemas"]["ConnectionPin"][];
-            sourceFormatNodeId: components["schemas"]["FormatNodeId"];
-            sourceOutput: components["schemas"]["OutputIdx"];
-            targetFormatNodeId: components["schemas"]["FormatNodeId"];
-            targetInput: components["schemas"]["InputIdx"];
-        };
+        FormatConnectionDTO: FormatConnectionDTO;
         FormatDAO: {
             description: string;
             category: components["schemas"]["NodeCategory"];
-            /** @default [] */
-            disqualificationKinds: components["schemas"]["DqKey"][];
+            /**
+             * @description Whether the format or a child format at any depth contains a game node. Derived from the nodes, not stored.
+             * @default false
+             */
+            containsGames: boolean;
+            customData: {
+                [key: string]: string;
+            };
+            /** @default {} */
+            disqualificationKinds: {
+                [key: string]: components["schemas"]["DqSettings"];
+            };
             /** @description The default values in here are not guaranteed to be valid for the signature. */
             docs: components["schemas"]["NodeVariantDoc"];
             errors: components["schemas"]["FormatValidationError"][];
@@ -1672,6 +1819,13 @@ declare interface components {
             id: components["schemas"]["FormatId"];
             name: string;
             signature: components["schemas"]["NodeSignature_for_Type_and_ParamRef"];
+            /**
+             * @default {
+             *       "nodes": {},
+             *       "sections": []
+             *     }
+             */
+            simplifiedView: components["schemas"]["SimplifiedView"];
             /** Format: uuid */
             templateOrigin?: string | null;
             valid: components["schemas"]["FormatValidity"];
@@ -1684,12 +1838,18 @@ declare interface components {
             /** @default  */
             description: string;
             connections: components["schemas"]["FormatConnectionDTO"][];
+            customData?: {
+                [key: string]: string;
+            };
             /**
              * @description All disqualifications that can escape this format. Like checked exceptions, every
              *      uncaught disqualification has to be declared and every declared one has to be throwable.
-             * @default []
+             *      Accepts the plain list of keys of older versions.
+             * @default {}
              */
-            disqualificationKinds: components["schemas"]["DqKey"][];
+            disqualificationKinds: {
+                [key: string]: components["schemas"]["DqSettings"];
+            };
             /** @description There must be docs for every input and output. Otherwise formats get rejected. */
             docs: components["schemas"]["NodeVariantDoc"];
             formatGroupId?: components["schemas"]["FormatGroupId"] | null;
@@ -1700,6 +1860,7 @@ declare interface components {
              *      Otherwise the signature will get inferred.
              */
             signature: components["schemas"]["NodeSignature_for_Type_and_ParamRef"];
+            simplifiedView?: components["schemas"]["SimplifiedView"];
         };
         FormatError: {
             /** @constant */
@@ -1749,6 +1910,9 @@ declare interface components {
         };
         FormatGroupDAO: {
             category: components["schemas"]["NodeCategory"];
+            customData: {
+                [key: string]: string;
+            };
             eventId: components["schemas"]["EventId"];
             id: components["schemas"]["FormatGroupId"];
             name: string;
@@ -1757,6 +1921,9 @@ declare interface components {
         };
         FormatGroupDTO: {
             category: components["schemas"]["NodeCategory"];
+            customData?: {
+                [key: string]: string;
+            };
             name: string;
         };
         /**
@@ -1853,6 +2020,9 @@ declare interface components {
             controlValues: {
                 [key: string]: components["schemas"]["Value_for_Primitive"];
             };
+            customData: {
+                [key: string]: string;
+            };
             formatId: components["schemas"]["FormatId"];
             /** @description When not yet persisted, this is a negative number unique to the graph */
             id: components["schemas"]["FormatNodeId"];
@@ -1865,7 +2035,6 @@ declare interface components {
              *      be the array varg type input.
              */
             inputVargsToArray: boolean;
-            /** @description Must always be formatted as serde formats in the db, because [Self::find_by_event_and_type] relies on that. */
             nodeType: components["schemas"]["NodeType"];
             /**
              * @description Only legal if the nodes outputs are variadic.
@@ -1891,31 +2060,7 @@ declare interface components {
             yPos: number;
         };
         /** @description For documentation about the node struct, checkout the docs for FormatNodeDAO. */
-        FormatNodeDTO: {
-            controlValues: {
-                [key: string]: components["schemas"]["Value_for_Primitive"];
-            };
-            /**
-             * @description Any unique id works, including for new nodes: whether the id refers to a new or an
-             *      existing node is determined by whether it already exists on the format, not by its value.
-             */
-            id: components["schemas"]["FormatNodeId"];
-            inputVargsToArray: boolean;
-            nodeType: components["schemas"]["NodeType"];
-            outputVargsToArray: boolean;
-            parentNodeId?: components["schemas"]["FormatNodeId"] | null;
-            settings: components["schemas"]["RecordValue_for_Primitive"];
-            /**
-             * @description Ignored for existing nodes, because a node's test id never changes. Defaults to the node id.
-             * @default null
-             */
-            testId: components["schemas"]["FormatNodeTestId"] | null;
-            typeHints: components["schemas"]["TypeHints_for_Type_and_ParamRef"];
-            /** Format: int64 */
-            xPos: number;
-            /** Format: int64 */
-            yPos: number;
-        };
+        FormatNodeDTO: FormatNodeDTO;
         /** Format: uuid */
         FormatNodeId: FormatNodeId;
         /** @description The node `format_node_id` in the format instance `format_instance_id`. */
@@ -1979,6 +2124,10 @@ declare interface components {
         } | {
             /** @constant */
             type: "portal-has-input-connection";
+        } | {
+            /** @constant */
+            type: "invalid-comment-link";
+            data: components["schemas"]["FormatNodeId"];
         } | {
             /** @constant */
             type: "parent-creates-cycle";
@@ -2190,150 +2339,38 @@ declare interface components {
             testFormatInstanceId: components["schemas"]["FormatInstanceHash"];
         };
         /** @description Represents a state in which the format is not valid for execution but can be stored in the db. */
-        FormatValidationError: {
-            /** @constant */
-            type: "uncaught-throw";
-            data: {
-                [key: string]: components["schemas"]["RowTypeHelper_for_ParamRef"][];
+        FormatValidationError: FormatValidationError;
+        /** @enum {string} */
+        FormatValidity: FormatValidity;
+        FullFormatDAO: {
+            format: components["schemas"]["FormatDAO"];
+            connections: components["schemas"]["FormatNodeConnectionDAO"][];
+            nodes: components["schemas"]["FormatNodeDAO"][];
+        };
+        FullFormatInstanceDTO: {
+            format: components["schemas"]["FormatDAO"];
+            formatInstance: components["schemas"]["FormatInstanceDAO"];
+            parent?: components["schemas"]["FullFormatInstanceDTO"] | null;
+            parentFormatNode?: components["schemas"]["FormatNodeDAO"] | null;
+            /**
+             * @description The folder names [Self::parent_format_node] sits in, outermost first.
+             *      Empty when that node is not inside a folder or when there is no such node.
+             */
+            parentFormatNodeFolderPath: string[];
+        };
+        /** @description The node `format_node_id` in the format instance `format_instance_id`. */
+        FullNodeInstance: {
+            formatId: components["schemas"]["FormatId"];
+            formatInstanceId: components["schemas"]["FormatInstanceHash"];
+            formatNodeId: components["schemas"]["FormatNodeId"];
+        };
+        GTFilterKind: GTFilterKind;
+        GameDAO: {
+            attributes: components["schemas"]["RecordValue_for_Primitive"];
+            customData: {
+                [key: string]: string;
             };
-        } | {
-            /** @constant */
-            type: "unthrown-disqualification-kinds";
-            data: components["schemas"]["DqKey"][];
-        } | {
-            /** @constant */
-            type: "root-format-with-disqualification-kinds";
-        } | {
-            /** @constant */
-            type: "graph-is-cyclic";
-        } | {
-            /** @constant */
-            type: "too-many-inputs";
-            data: components["schemas"]["ParentType"];
-        } | {
-            /** @constant */
-            type: "too-many-outputs";
-            data: components["schemas"]["ParentType"];
-        } | {
-            /** @constant */
-            type: "invalid-node";
-            data: [
-            components["schemas"]["FormatNodeId"],
-            components["schemas"]["InvalidNodeReason"]
-            ];
-        } | {
-            /** @constant */
-            type: "too-many-closure-inputs";
-        } | {
-            /** @constant */
-            type: "root-format-with-input-or-output";
-        } | {
-            /** @constant */
-            type: "child-format-is-invalid";
-            data: components["schemas"]["FormatId"];
-        } | {
-            /** @constant */
-            type: "root-format-referenced";
-            data: components["schemas"]["FormatId"];
-        } | {
-            /** @constant */
-            type: "cyclic-parent-relation";
-            data: components["schemas"]["FormatNodeId"][];
-        } | {
-            /** @constant */
-            type: "illegal-child";
-            data: components["schemas"]["FormatNodeId"];
-        } | {
-            /** @constant */
-            type: "parent-connected-to-child";
-            data: {
-                child: components["schemas"]["FormatNodeId"];
-                parent: components["schemas"]["FormatNodeId"];
-            };
-        } | {
-            /** @constant */
-            type: "connection-escapes-scope";
-            data: {
-                scope: components["schemas"]["FormatNodeId"];
-                source: components["schemas"]["FormatNodeId"];
-                target: components["schemas"]["FormatNodeId"];
-            };
-        } | {
-            /** @constant */
-            type: "input-or-output-node-with-parent";
-        } | {
-            /** @constant */
-            type: "node-configuration-error";
-            data: components["schemas"]["NodeConfigurationError"];
-        } | {
-            /** @constant */
-            type: "cyclic-format-dependency";
-        } | {
-            /** @constant */
-            type: "type-validation-errors";
-            data: components["schemas"]["ValidationError_for_Type"][];
-        } | {
-            /** @constant */
-            type: "static-input-received-non-static-connection";
-        } | {
-            /** @constant */
-            type: "nodety-error";
-            data: components["schemas"]["NodetyError"];
-        } | {
-            /** @constant */
-            type: "format-of-other-event-referenced";
-            data: components["schemas"]["FormatId"];
-        } | {
-            /** @constant */
-            type: "invalid-signature";
-        } | {
-            /** @constant */
-            type: "missing-output-node";
-        };
-        /** @enum {string} */
-        FormatValidity: "invalid" | "valid";
-        FullFormatDAO: {
-            format: components["schemas"]["FormatDAO"];
-            connections: components["schemas"]["FormatNodeConnectionDAO"][];
-            nodes: components["schemas"]["FormatNodeDAO"][];
-        };
-        FullFormatInstanceDTO: {
-            format: components["schemas"]["FormatDAO"];
-            formatInstance: components["schemas"]["FormatInstanceDAO"];
-            parent?: components["schemas"]["FullFormatInstanceDTO"] | null;
-            parentFormatNode?: components["schemas"]["FormatNodeDAO"] | null;
-            /**
-             * @description The folder names [Self::parent_format_node] sits in, outermost first.
-             *      Empty when that node is not inside a folder or when there is no such node.
-             */
-            parentFormatNodeFolderPath: string[];
-        };
-        /** @description The node `format_node_id` in the format instance `format_instance_id`. */
-        FullNodeInstance: {
-            formatId: components["schemas"]["FormatId"];
-            formatInstanceId: components["schemas"]["FormatInstanceHash"];
-            formatNodeId: components["schemas"]["FormatNodeId"];
-        };
-        GTFilterKind: {
-            /** @constant */
-            type: "class-filter";
-        } | {
-            /** @constant */
-            type: "gender";
-        } | {
-            /** @constant */
-            type: "comparison-filter";
-            data: components["schemas"]["ComparisonOp"];
-        } | {
-            /** @constant */
-            type: "custom";
-        };
-        GameDAO: {
-            attributes: components["schemas"]["RecordValue_for_Primitive"];
             eventId: components["schemas"]["EventId"];
-            extensionData: {
-                [key: string]: string;
-            };
             /**
              * Format: uint32
              * @description The game depth of the game's entry table.
@@ -2347,7 +2384,7 @@ declare interface components {
         };
         GameDTO: {
             attributes: components["schemas"]["RecordValue_for_Primitive"];
-            extensionData: {
+            customData?: {
                 [key: string]: string;
             };
             gameFormatId: components["schemas"]["GameFormatId"];
@@ -2362,11 +2399,18 @@ declare interface components {
         GameFormatDAO: {
             description: string;
             attributesType: components["schemas"]["RecordTypeWithDefaults"];
-            entryListColumns: components["schemas"]["RecordTypeWithDefaults"];
-            eventId: components["schemas"]["EventId"];
-            extensionData: {
+            customData: {
                 [key: string]: string;
             };
+            /**
+             * @description Settings by disqualification kind. May hold kinds no automation disqualifies under. Kinds without an entry have
+             *      the default settings.
+             */
+            disqualifications?: {
+                [key: string]: components["schemas"]["DqSettings"];
+            };
+            entryListColumns: components["schemas"]["RecordTypeWithDefaults"];
+            eventId: components["schemas"]["EventId"];
             id: components["schemas"]["GameFormatId"];
             name: string;
             /** @description Run in order on every result row. */
@@ -2385,10 +2429,17 @@ declare interface components {
             /** @default  */
             description: string;
             attributesType: components["schemas"]["RecordTypeWithDefaults"];
-            entryListColumns: components["schemas"]["RecordTypeWithDefaults"];
-            extensionData: {
+            customData?: {
                 [key: string]: string;
             };
+            /**
+             * @description Settings by disqualification kind. May hold kinds no automation disqualifies under. Kinds without an entry have
+             *      the default settings.
+             */
+            disqualifications?: {
+                [key: string]: components["schemas"]["DqSettings"];
+            };
+            entryListColumns: components["schemas"]["RecordTypeWithDefaults"];
             name: string;
             /** @description Run in order on every result row. */
             postProcessingSteps: components["schemas"]["GameFormatPostProcessingStep"][];
@@ -2410,22 +2461,7 @@ declare interface components {
          *      result, after the result has been entered. They never change the stored result of the game, only
          *      the result table the game node outputs.
          */
-        GameFormatPostProcessingStep: {
-            /** @constant */
-            type: "disqualify";
-            data: {
-                expression: string;
-                key: components["schemas"]["DqKey"];
-            };
-        } | {
-            /** @constant */
-            type: "set-output-column";
-            data: {
-                column: string;
-                columnType: components["schemas"]["TypeExpr_for_Type_and_ParamRef"];
-                expression: string;
-            };
-        };
+        GameFormatPostProcessingStep: GameFormatPostProcessingStep;
         /**
          * Format: uuid
          * @description Identifies a game, the primary key of `games`. Comes from one of:
@@ -2437,32 +2473,9 @@ declare interface components {
          *      Changing a derivation changes what replaying a log produces and needs an `ENGINE_VERSION` increment.
          */
         GameId: GameId;
-        GameNodeDTO: {
-            /**
-             * @description Caught disqualifications are not thrown. [DqStrategy] decides how they are surfaced.
-             * @default {}
-             */
-            catchDqs: {
-                [key: string]: components["schemas"]["DqStrategy"];
-            };
-            gameFormatId: components["schemas"]["GameFormatId"];
-            variant: components["schemas"]["GameNodeVariant"];
-        };
+        GameNodeDTO: GameNodeDTO;
         /** @description How many games a game node plays and how they depend on each other. */
-        GameNodeVariant: {
-            /** @constant */
-            type: "single";
-        } | {
-            /** @constant */
-            type: "parallel";
-        } | {
-            /** @constant */
-            type: "sequential";
-            data: {
-                /** Format: uint */
-                gameCount: number;
-            };
-        };
+        GameNodeVariant: GameNodeVariant;
         GamePathVariables_for_CommonWorkspaceId: {
             eventId: components["schemas"]["EventId"];
             gameId: components["schemas"]["GameId"];
@@ -2510,21 +2523,12 @@ declare interface components {
             strategy: components["schemas"]["UniqueBibStrategy"];
         };
         /** @description Location of a validation error in the graph. */
-        GraphLocation: {
-            /** @constant */
-            type: "Edge";
-            /** Format: uint */
-            data: number;
-        } | {
-            /** @constant */
-            type: "InputPort";
-            data: {
-                /** Format: uint */
-                inputIdx: number;
-                /** Format: uint */
-                nodeIdx: number;
-            };
-        };
+        GraphLocation: GraphLocation;
+        /**
+         * @description Contains other nodes. It can add its name to the folder path of its descendants and catch the disqualifications
+         *      they throw.
+         */
+        GroupNode: GroupNode;
         /**
          * @description The Header Object follows the structure of the Parameter Object with the
          *      following changes:
@@ -2657,28 +2661,8 @@ declare interface components {
             /** @constant */
             type: "missing-dependency";
         };
-        InvalidNodeReason: {
-            /** @constant */
-            type: "invalid-node";
-        } | {
-            /** @constant */
-            type: "node-is-not-variadic-but-vargs-to-array-set";
-        } | {
-            /** @constant */
-            type: "illegal-control-values";
-        } | ({
-            /** @constant */
-            type: "node-configuration-error";
-        } & components["schemas"]["NodeConfigurationError"]) | {
-            /** @constant */
-            type: "catching-disqualifications-of-variadic-format";
-        } | {
-            /** @constant */
-            type: "appending-disqualifications-to-incompatible-output";
-        } | {
-            /** @constant */
-            type: "game-result-not-assignable-to-entry";
-        };
+        InvalidLinkedFormatPolicy: "empty-table" | "node-error" | "last-known-table";
+        InvalidNodeReason: InvalidNodeReason;
         /** @description License information for the exposed API. */
         License: {
             /** @description An [SPDX](https://spdx.org/spdx-specification-21-web-version#h.jxpfx0ykyb60) license expression for the API. The `identifier` field is mutually exclusive of the `url` field. */
@@ -2762,7 +2746,7 @@ declare interface components {
          * @description Identifies a type parameter within a type expression or node signature.
          *      Can be created from a single character (e.g. `'T'`) or a string (hashed for multi-char names).
          */
-        LocalParamID: number;
+        LocalParamID: LocalParamID;
         /** @description An error that originated in a node, identified independently of the unstable `NodeIndex`. */
         LocatedNodeError: {
             error: components["schemas"]["NodeRuntimeError"];
@@ -2770,6 +2754,21 @@ declare interface components {
             formatId: components["schemas"]["FormatId"];
             formatInstanceId: components["schemas"]["FormatInstanceHash"];
             formatNodeId: components["schemas"]["FormatNodeId"];
+            nodeType: components["schemas"]["NodeTypeDiscriminants"];
+            /**
+             * @description The executed node instances that the steps in the lineage of the rows of `error` name, see
+             *      [graphite_table::Step::node]. Resolved here because the nodes may be gone by the time the error is shown, like
+             *      the ones of a rolled back mutation.
+             */
+            nodes: components["schemas"]["LocatedNodeInstance"][];
+        };
+        /** @description A node instance that the lineage of a [LocatedNodeError] names, see [LocatedNodeError::nodes]. */
+        LocatedNodeInstance: {
+            formatId: components["schemas"]["FormatId"];
+            formatInstanceId: components["schemas"]["FormatInstanceHash"];
+            formatNodeId: components["schemas"]["FormatNodeId"];
+            id: components["schemas"]["NodeInstanceHash"];
+            nodeType: components["schemas"]["NodeTypeDiscriminants"];
         };
         /** Format: uuid */
         LogBatchId: string;
@@ -2845,6 +2844,10 @@ declare interface components {
             /** @constant */
             type: "update-game-table";
             data: components["schemas"]["UpdateTableMutation"];
+        } | {
+            /** @constant */
+            type: "update-standalone-table";
+            data: components["schemas"]["UpdateStandaloneTableMutation"];
         } | {
             /** @constant */
             type: "delete-game-table";
@@ -2961,6 +2964,10 @@ declare interface components {
             /** @constant */
             type: "link-to-template";
             data: components["schemas"]["LinkToTemplateMutation"];
+        } | {
+            /** @constant */
+            type: "set-custom-data";
+            data: components["schemas"]["SetCustomDataMutation"];
         };
         LogEntrySmall: {
             description: string;
@@ -2998,9 +3005,7 @@ declare interface components {
             /** @description The exact name to give the copied format. */
             name: string;
         };
-        MakeValidError: {
-            missingDefaultField: string;
-        };
+        MakeValidError: MakeValidError;
         Map_of_TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type: {
             [key: string]: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
         };
@@ -3008,7 +3013,7 @@ declare interface components {
             [key: string]: components["schemas"]["TypeExpr_for_Type_and_ParamRef"];
         };
         /** @enum {string} */
-        MathNodeOp: "addition" | "subtraction" | "multiplication" | "division-float" | "division-integer" | "modulo" | "power" | "logarithm" | "sqrt" | "absolute" | "minimum" | "maximum" | "ceil" | "floor" | "round";
+        MathNodeOp: MathNodeOp;
         MediaType: {
             encoding?: {
                 [key: string]: components["schemas"]["Encoding"];
@@ -3021,43 +3026,21 @@ declare interface components {
         } & {
             [key: string]: unknown;
         };
+        /**
+         * @description What a continuation does with competitors of its parts that are missing from the previous result.
+         *      If the previous result is empty, nobody is missing: everyone's previous total is 0.
+         */
+        MissingFromPrevious: MissingFromPrevious;
         /** @enum {string} */
-        MultiplexingStrategy: "serpentine" | "round-robin";
+        MultiplexingStrategy: MultiplexingStrategy;
         NameQuery: {
             name: string;
         };
-        NoSupertypeLayerReason: "UnknownTypeParam" | "NodeSignatureInputsVarg" | "NodeSignatureInputs" | "NodeSignatureOutputs" | "NodeSignatureTags" | "NodeSignatureRequiredTags" | "PortTypesVarg" | "PortTypesArity" | "PortTypesPort" | "Index" | "ConstructorArity" | "ConstructorParam";
+        NoSupertypeLayerReason: NoSupertypeLayerReason;
         NoSupertypeLayer_for_Type: NoSupertypeLayer<Type>;
         /** @enum {string} */
         NodeCategory: "logic" | "game" | "tables" | "arrays" | "math" | "class" | "input-output" | "invalid" | "other" | "root";
-        NodeConfigurationError: {
-            /** @constant */
-            type: "extract-record-field-error";
-            data: components["schemas"]["ExtractRecordFieldError_for_Primitive"];
-        } | {
-            /** @constant */
-            type: "invalid-value";
-            data: {
-                givenValue: components["schemas"]["Value_for_SerializableNonPrimitiveValue"];
-                identifier: string;
-                message: string;
-            };
-        } | {
-            /** @constant */
-            type: "node-is-not-variadic-but-vargs-to-array-set";
-        } | {
-            /** @constant */
-            type: "found-closure-input-node-in-non-closure";
-        } | {
-            /** @constant */
-            type: "invalid-node";
-        } | {
-            /** @constant */
-            type: "illegal-vargs-to-array";
-        } | {
-            /** @constant */
-            type: "illegal-control-values";
-        };
+        NodeConfigurationError: NodeConfigurationError;
         NodeDocTest: {
             description?: string | null;
             format: components["schemas"]["FormatDTO"];
@@ -3107,12 +3090,22 @@ declare interface components {
             result: components["schemas"]["SerializableNodeResult"];
             testId: components["schemas"]["FormatNodeTestId"];
         };
+        /**
+         * Format: uuid
+         * @description Shared by the variants of one node, each in another group of the same section.
+         */
+        NodeLinkId: NodeLinkId;
         NodePathVariables_for_CommonWorkspaceId: {
             eventId: components["schemas"]["EventId"];
             formatId: components["schemas"]["FormatId"];
             nodeId: components["schemas"]["FormatNodeId"];
             workspaceId: components["schemas"]["CommonWorkspaceId"];
         };
+        NodePlacement: {
+            group?: components["schemas"]["SimplifiedGroupId"] | null;
+            link?: components["schemas"]["NodeLinkId"] | null;
+            section: components["schemas"]["SimplifiedSectionId"];
+        };
         NodePrototype: {
             /**
              * @description If there is only one variant, the node should not display a select for the variants.
@@ -3214,289 +3207,15 @@ declare interface components {
          * @description Function-like type for a node: generic parameters, inputs, outputs, and defaults.
          *      Written in notation as `<T>(T) -> (T)` for the identity node.
          */
-        NodeSignature_for_Type_and_ErasedScopedTypeRef_for_Type: {
-            /**
-             * @description Types that get used when there is no connection to the input.
-             *      These get ignored for nested NodeSignatures.
-             */
-            defaultInputTypes: {
-                [key: string]: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-            };
-            /**
-             * @description inputs and outputs are no PortTypes because having them TypeExpr
-             *      Enables one to express `() -> Never` which is the node signature
-             *      assignable to all other node signatures. Useful for inferring what
-             *      type a closure should be.
-             */
-            inputs: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-            outputs: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-            /** @description Generic parameters with their bounds and defaults. */
-            parameters: components["schemas"]["TypeParameters_for_Type_and_ErasedScopedTypeRef_for_Type"];
-            /**
-             * @description Tags this node *requires* from every incoming edge.
-             *
-             *      During validation, each incoming edge's source tags are checked against
-             *      this set. Any tag present here but missing from an incoming edge
-             *      produces a [`TagMissing`](crate::validation::ValidationErrorKind::TagMissing)
-             *      error.
-             *
-             *      Defaults to `∅` (no requirements).
-             */
-            requiredTags: number[];
-            /**
-             * @description Tags this node *provides* to downstream consumers.
-             *
-             *      - `Some(set)` — the node carries exactly the listed tags.
-             *      - `None` — the node carries *every* tag (universal set), making it a
-             *        supertype of all other tag sets.
-             *
-             *      Tags propagate forward through the graph: a node's effective tag set
-             *      is the intersection of its own `tags` with every incoming edge's tags.
-             *
-             *      Defaults to `Some(∅)` (no tags).
-             *
-             *      `u32` is used instead of `usize` for wasm compatibility (JS has 32-bit
-             *      integers).
-             */
-            tags?: number[] | null;
-        };
+        NodeSignature_for_Type_and_ErasedScopedTypeRef_for_Type: NodeSignature<Type, components["schemas"]["ErasedScopedTypeRef_for_Type"]>;
         /**
          * @description Function-like type for a node: generic parameters, inputs, outputs, and defaults.
          *      Written in notation as `<T>(T) -> (T)` for the identity node.
          */
         NodeSignature_for_Type_and_ParamRef: NodeSignature<Type, ParamRef>;
-        NodeType: {
-            /** @constant */
-            type: "input";
-        } | {
-            /** @constant */
-            type: "output";
-        } | {
-            /** @constant */
-            type: "format";
-            data: {
-                /**
-                 * @description Each of these get caught and handled according to [`DqStrategy`].
-                 * @default {}
-                 */
-                catchDqs: {
-                    [key: string]: components["schemas"]["DqStrategy"];
-                };
-                formatId: components["schemas"]["FormatId"];
-            };
-        } | {
-            /** @constant */
-            type: "math";
-            data: {
-                op: components["schemas"]["MathNodeOp"];
-            };
-        } | {
-            /** @constant */
-            type: "game";
-            data: components["schemas"]["GameNodeDTO"];
-        } | {
-            /** @constant */
-            type: "output-table";
-        } | {
-            /** @constant */
-            type: "input-table";
-            data: {
-                tableId: components["schemas"]["TableId"];
-            };
-        } | {
-            /** @constant */
-            type: "portal";
-            data: {
-                sourceNodeId: components["schemas"]["FormatNodeId"];
-                sourceOutput: components["schemas"]["OutputIdx"];
-            };
-        } | {
-            /** @constant */
-            type: "class";
-            data: {
-                classId: components["schemas"]["ClassId"];
-            };
-        } | {
-            /** @constant */
-            type: "catch-dq";
-            data: components["schemas"]["CatchDqNode"];
-        } | {
-            /** @constant */
-            type: "disqualify";
-            data: components["schemas"]["DisqualifyNode"];
-        } | {
-            /** @constant */
-            type: "folder";
-            data: {
-                folderName: string;
-            };
-        } | {
-            /** @constant */
-            type: "group";
-            data: {
-                name: string;
-            };
-        } | {
-            /** @constant */
-            type: "string-concat";
-        } | {
-            /** @constant */
-            type: "string-format";
-        } | {
-            /** @constant */
-            type: "sort-node";
-        } | {
-            /** @constant */
-            type: "constant";
-        } | {
-            /** @constant */
-            type: "merge-tables";
-        } | {
-            /** @constant */
-            type: "divide-table";
-        } | {
-            /** @constant */
-            type: "distribute-table";
-        } | {
-            /** @constant */
-            type: "split-table";
-            data: components["schemas"]["SplitTableNode"];
-        } | {
-            /** @constant */
-            type: "concat";
-            data: {
-                sorted: boolean;
-            };
-        } | {
-            /** @constant */
-            type: "remove-places";
-        } | {
-            /** @constant */
-            type: "table-map";
-        } | {
-            /** @constant */
-            type: "length";
-        } | {
-            /** @constant */
-            type: "boolean-op";
-            data: {
-                op: components["schemas"]["BooleanOp"];
-            };
-        } | {
-            /** @constant */
-            type: "record-field";
-            data: {
-                op: components["schemas"]["RecordFieldOp"];
-            };
-        } | {
-            /** @constant */
-            type: "add-record-fields";
-            data: components["schemas"]["AddRecordFieldsNode"];
-        } | {
-            /** @constant */
-            type: "fallback";
-        } | {
-            /** @constant */
-            type: "gt-row";
-            data: {
-                errorOnNotFound: boolean;
-            };
-        } | {
-            /** @constant */
-            type: "filter-gt";
-            data: {
-                filter: components["schemas"]["GTFilterKind"];
-            };
-        } | {
-            /** @constant */
-            type: "comparison";
-            data: {
-                op: components["schemas"]["ComparisonOp"];
-            };
-        } | {
-            /** @constant */
-            type: "comment";
-            data: {
-                comment: string;
-            };
-        } | {
-            /** @constant */
-            type: "ternary";
-        } | {
-            /** @constant */
-            type: "separate-row";
-        } | {
-            /** @constant */
-            type: "update-row";
-        } | {
-            /** @constant */
-            type: "array-map";
-        } | {
-            /** @constant */
-            type: "create-array";
-        } | {
-            /** @constant */
-            type: "create-table";
-        } | {
-            /** @constant */
-            type: "array-access";
-            data: {
-                errorOnNotFound: boolean;
-            };
-        } | {
-            /** @constant */
-            type: "unpack-array";
-            data: {
-                errorOnNotFound: boolean;
-            };
-        } | {
-            /** @constant */
-            type: "promotion-relegation";
-            data: {
-                /** Format: uint */
-                finalCount?: number | null;
-            };
-        } | {
-            /** @constant */
-            type: "age-at";
-        } | {
-            /** @constant */
-            type: "split-by-class";
-            data: {
-                /** Format: uint */
-                classCount: number;
-            };
-        } | {
-            /** @constant */
-            type: "invalid";
-            data: {
-                nodeType: components["schemas"]["NodeType"];
-            };
-        } | {
-            /** @constant */
-            type: "empty-record";
-        } | {
-            /** @constant */
-            type: "event-competitors";
-            data: components["schemas"]["EventCompetitorsNode"];
-        } | {
-            /** @constant */
-            type: "add-columns";
-            data: components["schemas"]["AddColumnsNode"];
-        } | {
-            /** @constant */
-            type: "matrix-transpose";
-        } | {
-            /** @constant */
-            type: "simple-scoring";
-            data: components["schemas"]["SimpleScoringNode"];
-        } | {
-            /** @constant */
-            type: "classes-competitors";
-            data: components["schemas"]["ClassesCompetitorsNode"];
-        };
+        NodeType: NodeType;
         /** @description Auto-generated discriminant enum variants */
-        NodeTypeDiscriminants: ("input" | "output" | "format" | "math" | "game" | "output-table" | "input-table" | "portal" | "class" | "catch-dq" | "disqualify" | "folder" | "group" | "string-concat" | "string-format" | "sort-node" | "constant" | "merge-tables" | "divide-table" | "distribute-table" | "split-table" | "concat" | "remove-places" | "table-map" | "length" | "boolean-op" | "record-field" | "add-record-fields" | "fallback" | "gt-row" | "filter-gt" | "comparison" | "comment" | "ternary" | "separate-row" | "update-row" | "array-map" | "create-array" | "create-table" | "array-access" | "unpack-array" | "promotion-relegation" | "age-at" | "split-by-class" | "empty-record" | "event-competitors" | "add-columns" | "matrix-transpose" | "simple-scoring" | "classes-competitors") | "invalid";
+        NodeTypeDiscriminants: ("input" | "output" | "format" | "math" | "game" | "input-table" | "portal" | "class" | "disqualify" | "group" | "string-concat" | "string-format" | "sort-node" | "constant" | "merge-tables" | "divide-table" | "distribute-table" | "split-table" | "concat" | "remove-places" | "table-map" | "length" | "boolean-op" | "record-field" | "add-record-fields" | "fallback" | "gt-row" | "filter-gt" | "comparison" | "comment" | "ternary" | "separate-row" | "update-row" | "array-map" | "create-array" | "create-table" | "array-access" | "unpack-array" | "promotion-relegation" | "age-at" | "split-by-class" | "empty-record" | "event-competitors" | "add-columns" | "matrix-transpose" | "simple-scoring" | "classes-competitors") | "output-table" | "invalid";
         NodeVariantDoc: {
             description?: string | null;
             /** @default other */
@@ -3532,23 +3251,7 @@ declare interface components {
             /** @description For the docs of format nodes */
             userDefinedDocs?: components["schemas"]["NodeVariantDoc"] | null;
         };
-        NodetyError: {
-            /** @constant */
-            type: "NodeHasChildren";
-        } | {
-            /** @constant */
-            type: "ParentNotFound";
-        } | {
-            /** @constant */
-            type: "NodeNotFound";
-        } | {
-            /** @constant */
-            type: "CycleDetected";
-        } | {
-            /** @constant */
-            type: "TypeExprValidationError";
-            error: components["schemas"]["TypeExprValidationError"];
-        };
+        NodetyError: NodetyError;
         OAuth2Flows: ({
             implicit: {
                 authorizationUrl: string;
@@ -3845,14 +3548,7 @@ declare interface components {
         /** Format: uint16 */
         OutputIdx: OutputIdx;
         /** @description References a local type parameter. This is context sensitive because parameters are scoped. */
-        ParamRef: {
-            /**
-             * @description If false, this reference will not be used to collect candidates for the parameter.
-             *      In the notation this is written as `!T`.
-             */
-            infer: boolean;
-            paramId: components["schemas"]["LocalParamID"];
-        };
+        ParamRef: ParamRef;
         Parameter: (({
             /**
              * @description A brief description of the parameter. This could
@@ -4101,37 +3797,8 @@ declare interface components {
                 [key: string]: components["schemas"]["MediaType"];
             };
         }));
-        ParentType: {
-            /** @constant */
-            type: "format-root";
-        } | {
-            /** @constant */
-            type: "closure-node";
-            data: components["schemas"]["FormatNodeId"];
-        };
-        ParseError: {
-            kind: components["schemas"]["ParseErrorKind"];
-            location: components["schemas"]["SourceLocation"];
-        };
-        ParseErrorKind: {
-            /** @constant */
-            type: "invalid-token";
-        } | {
-            /** @constant */
-            type: "unexpected-token";
-        } | {
-            /** @constant */
-            type: "expected-token";
-            data: {
-                expected: string;
-            };
-        } | {
-            /** @constant */
-            type: "invalid-number";
-        } | {
-            /** @constant */
-            type: "unterminated-string";
-        };
+        ParentType: ParentType;
+        ParseErrorKind: ParseErrorKind;
         PatchTableStateMutation: {
             /** @description None resets the table state */
             state?: components["schemas"]["TableState"] | null;
@@ -4231,10 +3898,7 @@ declare interface components {
             data: string;
         };
         /** @description A list of port types, optionally with a variadic type (`...T`). */
-        PortTypes_for_Type_and_ErasedScopedTypeRef_for_Type: {
-            ports: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"][];
-            varg?: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"] | null;
-        };
+        PortTypes_for_Type_and_ErasedScopedTypeRef_for_Type: PortTypes<Type, components["schemas"]["ErasedScopedTypeRef_for_Type"]>;
         /** @description A list of port types, optionally with a variadic type (`...T`). */
         PortTypes_for_Type_and_ParamRef: PortTypes<Type, ParamRef>;
         PortsDoc: {
@@ -4253,7 +3917,7 @@ declare interface components {
             minAge: number;
         };
         /** @description Crate local version of [std::convert::Infallible] */
-        Primitive: unknown;
+        Primitive: Primitive;
         PushTableRowMutationsMutation: {
             /**
              * @description Challenge for a client to prevent accidentally
@@ -4275,11 +3939,8 @@ declare interface components {
             seed: components["schemas"]["Seed"];
         };
         /** @enum {string} */
-        RecordFieldOp: "read-field" | "write-field";
-        RecordMakeValidMutation: {
-            columnName: string;
-            newValue: components["schemas"]["Value_for_Primitive"];
-        };
+        RecordFieldOp: RecordFieldOp;
+        RecordMakeValidMutation: RecordMakeValidMutation;
         RecordModifications: {
             /**
              * Format: uint
@@ -4311,9 +3972,7 @@ declare interface components {
             };
         };
         RecordValue_for_Primitive: RecordValue<Primitive>;
-        RecordValue_for_SerializableNonPrimitiveValue: {
-            [key: string]: components["schemas"]["Value_for_SerializableNonPrimitiveValue"];
-        };
+        RecordValue_for_SerializableNonPrimitiveValue: RecordValue<SerializableNonPrimitiveValue>;
         ReferenceOr_for_Example: {
             /**
              * @description A description which by default SHOULD override that of the
@@ -4568,6 +4227,8 @@ declare interface components {
             hash: number[];
             id: components["schemas"]["LogId"];
         };
+        /** @enum {string} */
+        ReplicationSide: "source" | "target";
         ReplicationTargetMultipart: {
             /** Format: binary */
             file: Blob;
@@ -4599,7 +4260,7 @@ declare interface components {
             [key: string]: unknown;
         };
         Resolve: {
-            keep: components["schemas"]["Side"];
+            keep: components["schemas"]["ReplicationSide"];
         };
         /** @description A table as nodes see it, without the results whose competitor is not in the entry of their game. */
         ResolvedTable: {
@@ -4679,67 +4340,28 @@ declare interface components {
             parentTableId?: components["schemas"]["TableId"] | null;
             /** @description The operations between the parent row and this one, in order. */
             steps: components["schemas"]["Step"][];
-            tableId: components["schemas"]["TableId"];
-        };
-        RowMutationChangeEvent: {
-            gameTableId: components["schemas"]["TableId"];
-        };
-        RowMutationDAO: {
-            /**
-             * Format: int64
-             * @description When performing batch actions like delete all, then all these will have the same batch id.
-             *      Otherwise it will get incremented. Used for undo & redo.
-             */
-            batch: number;
-            competitorId: components["schemas"]["CompetitorId"];
-            gameTableId: components["schemas"]["TableId"];
-            /** @description Counts per table, so it is unique only together with `game_table_id`. */
-            idx: components["schemas"]["RowMutationIdx"];
-            kind: components["schemas"]["RowMutationKind"];
-        };
-        /** Format: int64 */
-        RowMutationIdx: RowMutationIdx;
-        RowMutationKind: {
-            /** @constant */
-            type: "set-record-field";
-            field: string;
-            value: components["schemas"]["Value_for_Primitive"];
-        } | {
-            /** @constant */
-            type: "push-unranked";
-            columns: components["schemas"]["RecordValue_for_Primitive"];
-        } | {
-            /** @constant */
-            type: "remove";
-        } | {
-            /** @constant */
-            type: "set-place";
-            /** Format: uint */
-            place: number;
-        } | {
-            /** @constant */
-            type: "set-unranked";
-            /** Format: uint */
-            tiebraker: number;
-        } | {
-            /** @constant */
-            type: "set-place-and-tie-braker";
-            /** Format: uint */
-            place: number;
-            /** Format: uint */
-            tiebraker: number;
+            tableId: components["schemas"]["TableId"];
+        };
+        RowMutationChangeEvent: {
+            gameTableId: components["schemas"]["TableId"];
         };
-        RowMutationWithBatch: {
+        RowMutationDAO: {
             /**
              * Format: int64
              * @description When performing batch actions like delete all, then all these will have the same batch id.
              *      Otherwise it will get incremented. Used for undo & redo.
              */
             batch: number;
-            /** Format: int64 */
-            competitorId: number;
+            competitorId: components["schemas"]["CompetitorId"];
+            gameTableId: components["schemas"]["TableId"];
+            /** @description Counts per table, so it is unique only together with `game_table_id`. */
+            idx: components["schemas"]["RowMutationIdx"];
             kind: components["schemas"]["RowMutationKind"];
         };
+        /** Format: int64 */
+        RowMutationIdx: RowMutationIdx;
+        RowMutationKind: RowMutationKind;
+        RowMutationWithBatch: RowMutationWithBatch;
         RowQuery: {
             /** @description The competitor of the row */
             competitorId: components["schemas"]["CompetitorId"];
@@ -4752,52 +4374,10 @@ declare interface components {
             timestamp: string;
         };
         /** @description GameTableTypes types should **only** be manipulated though this helper to have a single source of truth for the structure. */
-        RowTypeHelper_for_ParamRef: {
-            columns: components["schemas"]["RecordTypeHelper_for_ParamRef"];
-        };
+        RowTypeHelper_for_ParamRef: RowTypeHelper<ParamRef>;
         Rows_for_Sorted: Rows<Sorted>;
         Rows_for_Unsorted: Rows<Unsorted>;
-        RuntimeErrorKind: {
-            /** @constant */
-            type: "division-by-zero";
-        } | {
-            /** @constant */
-            type: "variable-not-found";
-            data: {
-                name: string;
-            };
-        } | {
-            /** @constant */
-            type: "function-not-found";
-            data: {
-                name: string;
-            };
-        } | {
-            /** @constant */
-            type: "index-out-of-bounds";
-        } | {
-            /** @constant */
-            type: "invalid-index";
-        } | {
-            /** @constant */
-            type: "invalid-math-operands";
-        } | {
-            /** @constant */
-            type: "non-boolean-condition";
-        } | {
-            /** @constant */
-            type: "non-boolean-operand";
-        } | {
-            /** @constant */
-            type: "invalid-comparison-operands";
-        } | {
-            /** @constant */
-            type: "argument";
-            data: {
-                expected: string;
-                got: string;
-            };
-        };
+        RuntimeErrorKind: RuntimeErrorKind;
         SchemaObject: {
             /**
              * @description A free-form property to include an example of an instance for this
@@ -4881,27 +4461,7 @@ declare interface components {
             errorState: components["schemas"]["NodeErrorState_for_NodeRuntimeError"];
             values: components["schemas"]["SerializablePortValues_for_OutputIdx"];
         };
-        SerializableNonPrimitiveValue: {
-            /** @constant */
-            type: "game-table";
-            data: components["schemas"]["Table_for_Unsorted_and_StateMetadata"];
-        } | {
-            /** @constant */
-            type: "game-table-sorted";
-            data: components["schemas"]["Table_for_Sorted_and_StateMetadata"];
-        } | {
-            /** @constant */
-            type: "row";
-            data: components["schemas"]["Row"];
-        } | {
-            /** @constant */
-            type: "class";
-            /** Format: uuid */
-            data: string;
-        } | {
-            /** @constant */
-            type: "closure";
-        };
+        SerializableNonPrimitiveValue: SerializableNonPrimitiveValue;
         SerializablePortValues_for_InputIdx: {
             values: {
                 [key: string]: components["schemas"]["Value_for_SerializableNonPrimitiveValue"];
@@ -4965,6 +4525,12 @@ declare interface components {
         } & {
             [key: string]: unknown;
         };
+        /** @description Sets one key of the `custom_data` of an entity, `None` deletes it. */
+        SetCustomDataMutation: {
+            entity: components["schemas"]["CustomDataEntity"];
+            key: string;
+            value?: string | null;
+        };
         /** @description Adds or sets the extension to the given version */
         SetExtensionMutation: {
             eventId: components["schemas"]["EventId"];
@@ -4978,8 +4544,6 @@ declare interface components {
         SetFormatsFormatGroupQuery: {
             formatGroupId?: components["schemas"]["FormatGroupId"] | null;
         };
-        /** @enum {string} */
-        Side: "source" | "target";
         /**
          * @description Place 1 = 1 point, Place 2 = 2 points, etc.
          *      On tie, whoever won the part with the highest priority wins.
@@ -4993,20 +4557,43 @@ declare interface components {
          *      Competitors are the union of all parts: a competitor without a place in a part
          *      (missing from the table of that part, or in it without a place) scores one point
          *      more than that part has rows, so not finishing a part is always worse than
-         *      finishing it last.
+         *      finishing it last. An empty part has not taken place yet and scores 0 for everyone.
+         *
+         *      With `continues_previous`, the first input is the result of a previous scoring,
+         *      `Table<{total_points: Integer}, Sorted>`, and the totals add this node's parts to the previous `total_points`.
+         *      The previous result's other columns are carried over, those named like a part are replaced. Ties keep the
+         *      previous result's order.
          */
-        SimpleScoringNode: {
-            parts: components["schemas"]["SimpleScoringPart"][];
-        };
+        SimpleScoringNode: SimpleScoringNode;
         /** @description One scored part, e.g. a single race of a series. */
-        SimpleScoringPart: {
-            /** @description Used as the name of the output column holding the points of this part. */
+        SimpleScoringPart: SimpleScoringPart;
+        SimplifiedGroup: {
+            id: components["schemas"]["SimplifiedGroupId"];
             name: string;
-            /**
-             * Format: uint32
-             * @description Higher priority parts break ties first.
-             */
-            priority: number;
+        };
+        /**
+         * Format: uuid
+         * @description Unique per format, not only per section.
+         */
+        SimplifiedGroupId: SimplifiedGroupId;
+        SimplifiedSection: {
+            /** @description In display order. */
+            groups: components["schemas"]["SimplifiedGroup"][];
+            id: components["schemas"]["SimplifiedSectionId"];
+            name: string;
+        };
+        /** Format: uuid */
+        SimplifiedSectionId: SimplifiedSectionId;
+        /**
+         * @description How the simplified view arranges the format's nodes. Only the simplified view interprets it: the backend stores it,
+         *      keeps its references consistent ([Self::repaired]) and carries it over to copies with new node ids.
+         */
+        SimplifiedView: {
+            nodes: {
+                [key: string]: components["schemas"]["NodePlacement"];
+            };
+            /** @description In display order. */
+            sections: components["schemas"]["SimplifiedSection"][];
         };
         SnapshotMultipart: {
             /** Format: binary */
@@ -5051,12 +4638,7 @@ declare interface components {
             type: "internal";
         };
         /** @description 1-based line and column at the start of a token. */
-        SourceLocation: {
-            /** Format: uint */
-            column: number;
-            /** Format: uint */
-            line: number;
-        };
+        SourceLocation: SourceLocation;
         /**
          * @description Splits a sorted table at the given places, see `Table::split_n`.
          *
@@ -5069,35 +4651,15 @@ declare interface components {
          *      <C extends {}>(Table<C, Sorted>, Array<Integer>) -> (Array<Table<C, Sorted>>)
          *      ```
          */
-        SplitTableNode: {
-            /** @constant */
-            type: "static";
-            data: {
-                /** Format: uint16 */
-                splitCount: number;
-            };
-        } | {
-            /** @constant */
-            type: "dynamic";
-        };
+        SplitTableNode: SplitTableNode;
+        /** @description A standalone table of the user. Its kind is always [TableKind::Other], its state is set like the state of any table. */
         StandaloneTableDTO: {
             columnTypes: components["schemas"]["RecordTypeWithDefaults"];
             name: string;
-            /** @description If Some, sets either layer one or layer two state depending on who issues the request. */
-            state?: components["schemas"]["TableState"] | null;
-            tableKind: components["schemas"]["TableKind"];
-        };
-        Step: {
-            /**
-             * Format: uuid
-             * @description Whoever ran the operation, see [Origin::attributed]: the engine's `NodeInstanceHash`, a raw uuid because this
-             *      crate doesn't know engine types. None until it is attributed.
-             */
-            node?: string | null;
-            op: components["schemas"]["StepOp"];
         };
+        Step: Step;
         /** @description An operation that moved rows between or within tables. */
-        StepOp: ("sort" | "split" | "concat" | "merge" | "divide" | "filter" | "remove-places" | "set-places" | "promote-relegate" | "score") | "create";
+        StepOp: StepOp;
         StoreExtensionValueMutation: {
             eventId: components["schemas"]["EventId"];
             extension: string;
@@ -5216,9 +4778,9 @@ declare interface components {
             rows: components["schemas"]["Row"][];
         };
         /** @enum {string} */
-        TableSorting: "unsorted" | "sorted";
+        TableSorting: TableSorting;
         /** Format: int64 */
-        TableState: number;
+        TableState: TableState;
         /** @description Encodes the two columns `game_id` and `column_types` (exactly one of which must be NON NULL). */
         TableVariant: {
             /** @constant */
@@ -5238,15 +4800,9 @@ declare interface components {
             table: components["schemas"]["TableDAO"];
         };
         /** @description Combines rows with table attributes and state */
-        Table_for_Sorted_and_StateMetadata: {
-            rows: components["schemas"]["Rows_for_Sorted"];
-            state: components["schemas"]["TableState"];
-        };
+        Table_for_Sorted_and_StateMetadata: Table<Sorted, StateMetadata>;
         /** @description Combines rows with table attributes and state */
-        Table_for_Unsorted_and_StateMetadata: {
-            rows: components["schemas"]["Rows_for_Unsorted"];
-            state: components["schemas"]["TableState"];
-        };
+        Table_for_Unsorted_and_StateMetadata: Table<Unsorted, StateMetadata>;
         /**
          * @description Adds metadata to a single tag that is used by the
          *      Operation Object. It is not mandatory to have a
@@ -5391,6 +4947,8 @@ declare interface components {
         number,
         number
         ];
+        /** @description One way a row got to where it is. */
+        Trail: Trail;
         Type: Type;
         /**
          * @description Can be parsed from string with the following syntax:
@@ -5401,67 +4959,11 @@ declare interface components {
          *      - `{a: Integer} -> Float`
          *      - `{} -> Any`
          */
-        TypeContext: {
-            returnType: components["schemas"]["TypeExpr_for_Type_and_ParamRef"];
-            variables: {
-                [key: string]: components["schemas"]["TypeExpr_for_Type_and_ParamRef"];
-            };
-        };
-        TypeError: {
-            kind: components["schemas"]["TypeErrorKind"];
-            location: components["schemas"]["SourceLocation"];
-        };
-        TypeErrorKind: {
-            /** @constant */
-            type: "unknown-variable";
-            data: {
-                name: string;
-            };
-        } | {
-            /** @constant */
-            type: "unknown-function";
-            data: {
-                name: string;
-            };
-        } | {
-            /** @constant */
-            type: "wrong-arity";
-            data: {
-                /** Format: uint */
-                expected: number;
-                /** Format: uint */
-                got: number;
-                name: string;
-            };
-        } | {
-            /** @constant */
-            type: "type-mismatch";
-            data: {
-                expected: string;
-                got: string;
-            };
-        } | {
-            /** @constant */
-            type: "non-integer-index";
-        } | {
-            /** @constant */
-            type: "non-record-property-access";
-        } | {
-            /** @constant */
-            type: "nodety";
-            data: {
-                message: string;
-            };
-        };
-        TypeErrors: components["schemas"]["TypeError"][];
-        TypeExprValidationError: {
-            /** @constant */
-            type: "UnknownVar";
-            var: components["schemas"]["LocalParamID"];
-        } | {
-            /** @constant */
-            type: "CyclicReference";
-        };
+        TypeContext: TypeContext;
+        TypeError: TypeError_2;
+        TypeErrorKind: TypeErrorKind;
+        TypeErrors: TypeErrors;
+        TypeExprValidationError: TypeExprValidationError;
         /**
          * @description Type expression—the core type representation in nodety.
          *
@@ -5471,74 +4973,7 @@ declare interface components {
          *      [`PartialEq`], [`Eq`] and [`Hash`] are structural: `A | B` is not equal to `B | A`.
          *      [`Eq`] and [`Hash`] are available when `T: Eq + Hash`.
          */
-        TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type: {
-            /** @constant */
-            type: "Type";
-            data: components["schemas"]["Type"];
-        } | {
-            /** @constant */
-            type: "Constructor";
-            data: {
-                inner: components["schemas"]["Type"];
-                /** @description Type arguments / record fields. Iterates in insertion order; equality ignores order. */
-                parameters: components["schemas"]["Map_of_TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-            };
-        } | {
-            /** @constant */
-            type: "Operation";
-            data: {
-                a: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-                b: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-                operator: components["schemas"]["ArithmeticOperator"];
-            };
-        } | {
-            /** @constant */
-            type: "NodeSignature";
-            data: components["schemas"]["NodeSignature_for_Type_and_ErasedScopedTypeRef_for_Type"];
-        } | {
-            /** @constant */
-            type: "PortTypes";
-            data: components["schemas"]["PortTypes_for_Type_and_ErasedScopedTypeRef_for_Type"];
-        } | {
-            /** @constant */
-            type: "Union";
-            data: [
-            components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"],
-            components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"]
-            ];
-        } | {
-            /** @constant */
-            type: "KeyOf";
-            data: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-        } | {
-            /** @constant */
-            type: "Index";
-            data: {
-                expr: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-                index: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"];
-            };
-        } | {
-            /** @constant */
-            type: "Intersection";
-            data: [
-            components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"],
-            components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"]
-            ];
-        } | {
-            /** @constant */
-            type: "Conditional";
-            data: components["schemas"]["Conditional_for_Type_and_ErasedScopedTypeRef_for_Type"];
-        } | {
-            /** @constant */
-            type: "Any";
-        } | {
-            /** @constant */
-            type: "Never";
-        } | {
-            /** @constant */
-            type: "Ref";
-            data: components["schemas"]["ErasedScopedTypeRef_for_Type"];
-        };
+        TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type: TypeExpr<Type, components["schemas"]["ErasedScopedTypeRef_for_Type"]>;
         /**
          * @description Type expression—the core type representation in nodety.
          *
@@ -5548,108 +4983,25 @@ declare interface components {
          *      [`PartialEq`], [`Eq`] and [`Hash`] are structural: `A | B` is not equal to `B | A`.
          *      [`Eq`] and [`Hash`] are available when `T: Eq + Hash`.
          */
-        TypeExpr_for_Type_and_ParamRef: {
-            /** @constant */
-            type: "Type";
-            data: components["schemas"]["Type"];
-        } | {
-            /** @constant */
-            type: "Constructor";
-            data: {
-                inner: components["schemas"]["Type"];
-                /** @description Type arguments / record fields. Iterates in insertion order; equality ignores order. */
-                parameters: components["schemas"]["Map_of_TypeExpr_for_Type_and_ParamRef"];
-            };
-        } | {
-            /** @constant */
-            type: "Operation";
-            data: {
-                a: components["schemas"]["TypeExpr_for_Type_and_ParamRef"];
-                b: components["schemas"]["TypeExpr_for_Type_and_ParamRef"];
-                operator: components["schemas"]["ArithmeticOperator"];
-            };
-        } | {
-            /** @constant */
-            type: "NodeSignature";
-            data: components["schemas"]["NodeSignature_for_Type_and_ParamRef"];
-        } | {
-            /** @constant */
-            type: "PortTypes";
-            data: components["schemas"]["PortTypes_for_Type_and_ParamRef"];
-        } | {
-            /** @constant */
-            type: "Union";
-            data: [
-            components["schemas"]["TypeExpr_for_Type_and_ParamRef"],
-            components["schemas"]["TypeExpr_for_Type_and_ParamRef"]
-            ];
-        } | {
-            /** @constant */
-            type: "KeyOf";
-            data: components["schemas"]["TypeExpr_for_Type_and_ParamRef"];
-        } | {
-            /** @constant */
-            type: "Index";
-            data: {
-                expr: components["schemas"]["TypeExpr_for_Type_and_ParamRef"];
-                index: components["schemas"]["TypeExpr_for_Type_and_ParamRef"];
-            };
-        } | {
-            /** @constant */
-            type: "Intersection";
-            data: [
-            components["schemas"]["TypeExpr_for_Type_and_ParamRef"],
-            components["schemas"]["TypeExpr_for_Type_and_ParamRef"]
-            ];
-        } | {
-            /** @constant */
-            type: "Conditional";
-            data: components["schemas"]["Conditional_for_Type_and_ParamRef"];
-        } | {
-            /** @constant */
-            type: "Any";
-        } | {
-            /** @constant */
-            type: "Never";
-        } | {
-            /** @constant */
-            type: "Ref";
-            data: components["schemas"]["ParamRef"];
-        };
+        TypeExpr_for_Type_and_ParamRef: TypeExpr<Type, ParamRef>;
         /** @description Type hints for pre-inference annotations (e.g. `T = Integer, U = String`). */
-        TypeHints_for_Type_and_ParamRef: {
-            [key: string]: components["schemas"]["TypeExpr_for_Type_and_ParamRef"];
-        };
+        TypeHints_for_Type_and_ParamRef: TypeHints<Type, ParamRef>;
         /** @description A generic type parameter with optional bound and default. */
-        TypeParameter_for_Type_and_ErasedScopedTypeRef_for_Type: {
-            /** @description Upper bound (e.g. `T extends Comparable`). */
-            bound?: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"] | null;
-            /** @description Default when not inferred (e.g. `T = Any`). */
-            default?: components["schemas"]["TypeExpr_for_Type_and_ErasedScopedTypeRef_for_Type"] | null;
-        };
+        TypeParameter_for_Type_and_ErasedScopedTypeRef_for_Type: TypeParameter<Type, components["schemas"]["ErasedScopedTypeRef_for_Type"]>;
         /** @description A generic type parameter with optional bound and default. */
-        TypeParameter_for_Type_and_ParamRef: {
-            /** @description Upper bound (e.g. `T extends Comparable`). */
-            bound?: components["schemas"]["TypeExpr_for_Type_and_ParamRef"] | null;
-            /** @description Default when not inferred (e.g. `T = Any`). */
-            default?: components["schemas"]["TypeExpr_for_Type_and_ParamRef"] | null;
-        };
+        TypeParameter_for_Type_and_ParamRef: TypeParameter<Type, ParamRef>;
         /**
          * @description Wrapper for BtreeMap
          *
          *      Exists so that it can implement traits like [std::str::FromStr]
          */
-        TypeParameters_for_Type_and_ErasedScopedTypeRef_for_Type: {
-            [key: string]: components["schemas"]["TypeParameter_for_Type_and_ErasedScopedTypeRef_for_Type"];
-        };
+        TypeParameters_for_Type_and_ErasedScopedTypeRef_for_Type: TypeParameters<Type, components["schemas"]["ErasedScopedTypeRef_for_Type"]>;
         /**
          * @description Wrapper for BtreeMap
          *
          *      Exists so that it can implement traits like [std::str::FromStr]
          */
-        TypeParameters_for_Type_and_ParamRef: {
-            [key: string]: components["schemas"]["TypeParameter_for_Type_and_ParamRef"];
-        };
+        TypeParameters_for_Type_and_ParamRef: TypeParameters<Type, ParamRef>;
         UninstalledExtensionPath: {
             extensionIdent: components["schemas"]["ExtensionIdentifier"];
         };
@@ -5750,6 +5102,24 @@ declare interface components {
             game: components["schemas"]["GameDTO"];
             id: components["schemas"]["GameId"];
         };
+        /** @description Renames a standalone table of the user and sets its column types. */
+        UpdateStandaloneTableMutation: {
+            /**
+             * @description Makes the rows and row mutations valid for changed column types, see [RecordTypeWithDefaults::make_valid].
+             *      Without it, the update fails if that would change any of them.
+             */
+            modifyRows: boolean;
+            table: components["schemas"]["StandaloneTableDTO"];
+            tableId: components["schemas"]["TableId"];
+        };
+        UpdateStandaloneTableQuery: {
+            /**
+             * @description If true, makes the rows and row mutations valid for changed column types (missing or mistyped columns get the
+             *      column's default). Otherwise the update fails with `change-would-modify-rows` if that would change any of them.
+             * @default false
+             */
+            modifyRows: boolean;
+        };
         UpdateTableMutation: {
             table: components["schemas"]["TableDTO"];
             tableId: components["schemas"]["TableId"];
@@ -5856,6 +5226,14 @@ export declare interface Conditional<T, R> {
 
 export declare function confirmDeleteItem(modalControls: ModalControls, itemName: string): Promise<boolean>;
 
+/**
+ * A pin that reroutes a connection
+ */
+declare interface ConnectionPin {
+    x: number;
+    y: number;
+}
+
 /**
  * Named type arguments of a [`TypeExpr::Constructor`](crate::TypeExpr::Constructor).
  *
@@ -5919,8 +5297,73 @@ export declare interface DialogButton<T> {
     theme?: 'primary' | 'default' | 'danger';
 }
 
+declare interface DialogOptions {
+    /** Shows it in a window (see `ModalConfig.window`), for content with links that the user may follow first. */
+    window?: {
+        title: ReactNode;
+    };
+}
+
+/**
+ * Greys out a disabled competitor wherever it is shown. Nodes don't spawn disabled competitors, but they can still be
+ * in classes and tables.
+ */
+export declare function disabledCompetitorClassName(competitor: Pick<CompetitorDAO, 'enabled'> | undefined): string | undefined;
+
+/**
+ * Disqualifies every row of the table it receives, throwing them all under `key` so that a
+ * [`GroupNode`](super::group_node::GroupNode) further up the graph can collect them.
+ */
+declare interface DisqualifyNode {
+    key: DqKey;
+}
+
+/**
+ * What a node does by default with a disqualification it can throw.
+ */
+declare type DqDefaultStrategy = "throw" | "output-placed" | "output-unplaced" | "append-placed" | "append-unplaced";
+
+/** A caught disqualification. The strategy decides how multiple caught tables of the key get merged. */
+declare interface DqEntry {
+    key: DqKey_2;
+    mergeStrategy: MultiplexingStrategy_2;
+}
+
+declare type DqKey = string;
+
+declare type DqKey_2 = components['schemas']['DqKey'];
+
+/**
+ * What a format or game format says about one of its disqualification kinds.
+ */
+declare interface DqSettings {
+    description: string;
+    /**
+     * Initialises `catch_dqs` of new nodes.
+     */
+    defaultStrategy: DqDefaultStrategy;
+}
+
+/**
+ * Decides how caught disqualifications are surfaced.
+ */
+declare type DqStrategy = "output-placed" | "output-unplaced" | "append-placed" | "append-unplaced";
+
+/** How a game or format node surfaces a disqualification it catches. */
+declare type DqStrategy_2 = components['schemas']['DqStrategy'];
+
 export declare type DraggableChildProps = React_2.HTMLAttributes<HTMLElement> & React_2.RefAttributes<HTMLElement>;
 
+/** An element is identified by its primary node: the source, game or result table node, or the first node of a stage. */
+declare type ElementId = FormatNodeId;
+
+/** A port of an element, or the output of a group that catches disqualifications (`element` is the group's id then). */
+declare interface ElementPortRef {
+    element: ElementId | FolderId;
+    /** Index into the element's `inputs` (target) or `outputs` (source). */
+    port: number;
+}
+
 /** Spelled out because the inferred `queryOptions` type references TanStack's unexported `dataTagSymbol`, which breaks the SDK's declaration rollup. */
 export declare type EngineQueryOptions<T> = UnusedSkipTokenOptions<T, Error, T, readonly unknown[]> & {
     queryKey: DataTag<readonly unknown[], T, Error>;
@@ -5931,9 +5374,15 @@ export declare type EngineQueryOptions<T> = UnusedSkipTokenOptions<T, Error, T,
  */
 declare type ErasedScopedTypeRef<T> = { type: "Param"; data: ParamRef } | { type: "ScopedExpr"; data: { expr: TypeExpr<T, ErasedScopedTypeRef<T>> } };
 
+declare type EventCompetitorsNode = CompetitorType_2;
+
 export declare const eventFoldersByEventQueryOptions: (workspaceId: CommonWorkspaceId, eventId: EventId) => EngineQueryOptions<ContentInEventFolderDTO[]>;
 
-export declare type EventId = Brand<string, 'eventId'>;
+/**
+ * Identifies an event. Random ([Self::new_random]): the endpoint picks it and `AddEventMutation` carries it.
+ * Deserializing one only yields a reference to an existing event; it does not check that it exists.
+ */
+export declare type EventId = string & { readonly __brand: 'eventId' };
 
 export declare interface EventPath {
     workspaceId: CommonWorkspaceId;
@@ -6039,6 +5488,8 @@ export declare interface ExtensionSidebarContribution {
 
 export declare type ExtensionSidebarProps = EventPath;
 
+declare type ExtractRecordFieldError<T> = { type: "field-does-not-exist"; data: string } | { type: "invalid-type"; data: { field: string; value: Value<T> | null } };
+
 export declare interface FieldTypeWithDefault {
     fieldType: TypeExpr<Type>;
     /**
@@ -6047,24 +5498,89 @@ export declare interface FieldTypeWithDefault {
     default: Value | null;
 }
 
+/** Games and result tables live in folders, and folders in folders. */
+declare type FolderContentRef = {
+    type: 'element';
+    id: ElementId;
+} | {
+    type: 'folder';
+    id: FolderId;
+};
+
+declare type FolderId = FormatNodeId;
+
 /**
  * How a competitor is written out. Kept apart from the components that show competitors so both
  * the picker and the selector can reach it without importing each other.
  */
 export declare function formatCompetitorName(competitor: CompetitorDAO): string;
 
+declare interface FormatConnectionDTO {
+    sourceFormatNodeId: FormatNodeId;
+    targetFormatNodeId: FormatNodeId;
+    sourceOutput: OutputIdx;
+    targetInput: InputIdx;
+    pins: ConnectionPin[];
+}
+
 declare type FormatGroupId = Brand<string, 'formatGroupId'>;
 
-declare type FormatId = Brand<string, 'formatId'>;
+/**
+ * Identifies a format. Comes from one of:
+ * - [Self::new_random]: the endpoint picks it and `AddFormatMutation` carries it.
+ * - [Self::root_of]: the root format of an event.
+ * - [Self::of_copy]: the copy a mutation makes with a seed.
+ * - `ImportArchiveMutation`: derived from the seed, the event and the archive entry.
+ *
+ * Deserializing one only yields a reference to an existing format; it does not check that it exists.
+ */
+declare type FormatId = string & { readonly __brand: 'formatId' };
 
 export declare type FormatInstanceHash = Brand<string, 'formatInstanceHash'>;
 
-export declare type FormatNodeId = Brand<string, 'formatNodeId'>;
+/**
+ * For documentation about the node struct, checkout the docs for FormatNodeDAO.
+ */
+declare interface FormatNodeDTO {
+    /**
+     * Any unique id works, including for new nodes: whether the id refers to a new or an
+     * existing node is determined by whether it already exists on the format, not by its value.
+     */
+    id: FormatNodeId;
+    /**
+     * Ignored for existing nodes, because a node's test id never changes. Defaults to the node id.
+     */
+    testId?: FormatNodeTestId | null;
+    xPos: number;
+    yPos: number;
+    nodeType: NodeType;
+    parentNodeId: FormatNodeId | null;
+    settings: RecordValue<Primitive>;
+    controlValues: Record<number, Value>;
+    typeHints: TypeHints<Type>;
+    inputVargsToArray: boolean;
+    outputVargsToArray: boolean;
+    customData?: Record<string, string>;
+}
+
+declare type FormatNodeDTO_2 = components['schemas']['FormatNodeDTO'] & {
+    addedInputVargs?: number;
+    addedOutputVargs?: number;
+};
+
+export declare type FormatNodeId = string & { readonly __brand: 'formatNodeId' };
 
-declare type FormatNodeTestId = Brand<string, 'formatNodeTestId'>;
+declare type FormatNodeTestId = string & { readonly __brand: 'formatNodeTestId' };
 
 declare type FormatTestId = Brand<string, 'formatTestId'>;
 
+/**
+ * Represents a state in which the format is not valid for execution but can be stored in the db.
+ */
+declare type FormatValidationError = { type: "uncaught-throw"; data: Record<DqKey, RowTypeHelper[]> } | { type: "unthrown-disqualification-kinds"; data: DqKey[] } | { type: "root-format-with-disqualification-kinds" } | { type: "graph-is-cyclic" } | { type: "too-many-inputs"; data: ParentType } | { type: "too-many-outputs"; data: ParentType } | { type: "invalid-node"; data: [FormatNodeId, InvalidNodeReason] } | { type: "too-many-closure-inputs" } | { type: "root-format-with-input-or-output" } | { type: "child-format-is-invalid"; data: FormatId } | { type: "root-format-referenced"; data: FormatId } | { type: "cyclic-parent-relation"; data: FormatNodeId[] } | { type: "illegal-child"; data: FormatNodeId } | { type: "parent-connected-to-child"; data: { parent: FormatNodeId; child: FormatNodeId } } | { type: "connection-escapes-scope"; data: { source: FormatNodeId; target: FormatNodeId; scope: FormatNodeId } } | { type: "input-or-output-node-with-parent" } | { type: "node-configuration-error"; data: NodeConfigurationError } | { type: "cyclic-format-dependency" } | { type: "type-validation-errors"; data: ValidationError<Type>[] } | { type: "static-input-received-non-static-connection" } | { type: "nodety-error"; data: NodetyError } | { type: "format-of-other-event-referenced"; data: FormatId } | { type: "invalid-signature" } | { type: "missing-output-node" };
+
+declare type FormatValidity = "invalid" | "valid";
+
 export declare type FormContribution<Props, DTO> = FC<Props & {
     formFieldRegistry: FormFieldRegistry;
     ref: Ref<ContributionHandle<DTO>>;
@@ -6111,6 +5627,11 @@ export declare interface FormFieldProps<I, O = I> {
     isNew?: boolean;
     registry?: FormFieldRegistry;
     map?: (value: I) => O;
+    /**
+     * Persists the overwritten value under this key (see `usePersistedState`), so that it survives leaving the page.
+     * Only the key passed in first is used.
+     */
+    persistenceKey?: string | null;
 }
 
 export declare interface FormFieldRegistry {
@@ -6137,11 +5658,26 @@ export declare type FormFieldState<T> = [value: T, setValue: (value: T | ((oldVa
 
 export declare type GameDAO = components['schemas']['GameDAO'];
 
+declare type GameDivision = {
+    type: 'fixed';
+    strategy: 'serpentine' | 'roundrobin';
+    count: number;
+} | {
+    type: 'dynamic';
+    strategy: 'serpentine' | 'roundrobin';
+    maxSize: number;
+    allowBackfill: boolean;
+};
+
 export declare type GameDTO = components['schemas']['GameDTO'];
 
 export declare type GameFormatDTO = components['schemas']['GameFormatDTO'];
 
-export declare type GameFormatId = Brand<string, 'gameFormatId'>;
+/**
+ * Identifies a game format. Random ([Self::new_random]) from the endpoint, or derived by `ImportArchiveMutation`.
+ * Deserializing one only yields a reference to an existing game format; it does not check that it exists.
+ */
+export declare type GameFormatId = string & { readonly __brand: 'gameFormatId' };
 
 export declare type GameFormatPageContribution = FormContribution<GameFormatPageProps & {
     gameFormat: GameFormatDTO;
@@ -6151,8 +5687,40 @@ export declare type GameFormatPageProps = EventPath & {
     gameFormatId: GameFormatId | null;
 };
 
+/**
+ * One step of a game format's post processing. Automations run in order on every row of a game's
+ * result, after the result has been entered. They never change the stored result of the game, only
+ * the result table the game node outputs.
+ */
+declare type GameFormatPostProcessingStep = { type: "disqualify"; data: { key: DqKey; expression: string } } | { type: "set-output-column"; data: { column: string; columnType: TypeExpr<Type>; expression: string } };
+
 export declare type GameId = Brand<string, 'gameId'>;
 
+declare type GameKind = {
+    type: 'game-node';
+    gameFormatId: GameFormatId;
+    variant: GameNodeVariant_2;
+} | {
+    type: 'gamified-format';
+    formatId: FormatId;
+};
+
+declare interface GameNodeDTO {
+    variant: GameNodeVariant;
+    gameFormatId: GameFormatId;
+    /**
+     * Caught disqualifications are not thrown. [DqStrategy] decides how they are surfaced.
+     */
+    catchDqs?: Record<DqKey, DqStrategy>;
+}
+
+/**
+ * How many games a game node plays and how they depend on each other.
+ */
+declare type GameNodeVariant = { type: "single" } | { type: "parallel" } | { type: "sequential"; data: { gameCount: number } };
+
+declare type GameNodeVariant_2 = components['schemas']['GameNodeVariant'];
+
 export declare type GamePageContribution = FormContribution<GamePageProps & {
     game: WorkingGameDTO;
 }, WorkingGameDTO>;
@@ -6161,6 +5729,9 @@ export declare type GamePageProps = EventPath & {
     gameId: GameId | null;
 };
 
+/** Where a game goes in the simplified view of the root format. */
+declare type GamePlace = Omit<AddGameEdit, 'type' | 'game' | 'division'>;
+
 export declare const gamesWithTablesMappedByEventQO: (workspaceId: CommonWorkspaceId, eventId: EventId) => EngineQueryOptions<Map<GameId, GameWithTables>>;
 
 export declare type GameWithTables = components['schemas']['GameWithTables'];
@@ -6192,6 +5763,39 @@ export declare const getTableByIdQueryOptions: (workspaceId: CommonWorkspaceId,
  */
 declare type GraphLocation = { type: "Edge"; data: number } | { type: "InputPort"; data: { nodeIdx: number; inputIdx: number } };
 
+/**
+ * Contains other nodes. It can add its name to the folder path of its descendants and catch the disqualifications
+ * they throw.
+ */
+declare interface GroupNode {
+    name: string;
+    /**
+     * Whether the name is appended to the folder path of the descendants.
+     */
+    folder: boolean;
+    /**
+     * The node has one output per catch key, in order. The strategy decides how multiple
+     * caught tables of the same key get merged.
+     */
+    catches: Record<DqKey, MultiplexingStrategy>;
+}
+
+/** The settings of a group node: BE-C's unified folder, group and catch-dq node. */
+declare interface GroupSettings {
+    /**
+     * `null` for an unnamed group that is no folder (an empty name in the node), which only catches. With `folder` the
+     * name is added to the path of the content.
+     */
+    name: {
+        text: string;
+        folder: boolean;
+    } | null;
+    /** In the order of the group's outputs, one per caught key. */
+    catches: DqEntry[];
+}
+
+declare type GTFilterKind = { type: "class-filter" } | { type: "gender" } | { type: "comparison-filter"; data: ComparisonOp } | { type: "custom" };
+
 export declare const H1: FC<H1Props>;
 
 export declare interface H1Props {
@@ -6213,7 +5817,7 @@ export declare type HRProps = {
     className?: string;
 };
 
-declare type InputIdx = Brand<number, 'inputIdx'>;
+declare type InputIdx = number & { readonly __brand: 'inputIdx' };
 
 export declare enum InputLayout {
     Normal = 0,
@@ -6225,6 +5829,23 @@ export declare enum InputLayout {
     Fill = 2
 }
 
+declare type InvalidNodeReason = { type: "invalid-node" } | { type: "node-is-not-variadic-but-vargs-to-array-set" } | { type: "illegal-control-values" } | ({ type: "node-configuration-error" } & NodeConfigurationError) | { type: "catching-disqualifications-of-variadic-format" } | { type: "appending-disqualifications-to-incompatible-output" } | { type: "game-result-not-assignable-to-entry" };
+
+/** Anything that can be selected and removed. A connection is identified by its target port: inputs take one connection. */
+declare type ItemRef = {
+    type: 'element';
+    id: ElementId;
+} | {
+    type: 'connection';
+    target: ElementPortRef;
+} | {
+    type: 'folder';
+    id: FolderId;
+} | {
+    type: 'comment';
+    id: FormatNodeId;
+};
+
 /** Loads graphite-script from the host's wasm on demand, a static import would make this entry an async module. */
 export declare const loadGraphiteScript: () => Promise<{
     primValueToTypeExpr: typeof primValueToTypeExpr;
@@ -6261,10 +5882,320 @@ export declare interface LogOperation {
     entries: LogEntry[];
 }
 
+/**
+ * A change to the lowered view. Nodeification turns it into one change of the node graph. The output `connectFrom` is
+ * connected to the first input of the new game or result table that its kind and type fit.
+ */
+declare type LoweredFormatEdit = 
+/**
+* Into `section`, or into a new section of its own with null; connected into the input `connectTo` if given, replacing
+* its connection like `connect` does.
+*/
+    {
+    type: 'add-source';
+    source: SourceKind;
+    section: SectionId | null;
+    connectTo?: ElementPortRef;
+}
+/** A new game or result table goes where `at` points, e.g. first, or where a connection was dropped. */
+| AddGameEdit_2 | {
+    type: 'add-result';
+    section: SectionId;
+    at: MoveTarget;
+    name: string;
+    connectFrom?: ElementPortRef;
+}
+/**
+* Settings of a node, e.g. a game's variant or the values of unconnected inputs. Drops connections at lost ports. With
+* `groups`, the changed values reach the node's siblings in these groups only, instead of those visible.
+*/
+| {
+    type: 'update-node';
+    node: FormatNodeId;
+    update: NodeUpdate;
+    groups?: SimplifiedGroupId[];
+}
+/**
+* Replaces the connection that currently ends at `target`, if any. With `movedFrom`, also removes the one ending there.
+* A stage that fed nothing else goes with a replaced connection, and with it the connection into it.
+* With `stage`, connects through a new stage node: into its first input that fits `source`, out of its first output
+* that fits `target`.
+*/
+/** A stage fed by `connectFrom`, its output left open, e.g. to connect a game to later. */
+| {
+    type: 'add-stage';
+    section: SectionId;
+    stage: StageSpec;
+    connectFrom: ElementPortRef;
+} | {
+    type: 'connect';
+    source: ElementPortRef;
+    target: ElementPortRef;
+    movedFrom?: ElementPortRef;
+    stage?: StageSpec;
+}
+/** Connects each of the `sources`, each a group's own, into the copy of the shared `target` in its group. */
+| {
+    type: 'connect-groups';
+    sources: ElementPortRef[];
+    target: ElementPortRef;
+}
+/** Connects the `sources`, one per group, through a new `merger` into `target`, in their order (see `mergers`). */
+| {
+    type: 'merge';
+    section: SectionId;
+    sources: ElementPortRef[];
+    target: ElementPortRef;
+    merger: StageSpec;
+} | {
+    type: 'remove';
+    items: ItemRef[];
+}
+/**
+* Gives a result table a scoring of `parts` (see `ResultScoring`), changes it, or with null takes it away. Each part
+* keeps what came into the input it had before (`from`: of the parts before, or 0 for the table's own input without a
+* scoring); without a scoring the table keeps what came into the first part. What the overall standing fed, the new
+* overall standing feeds. What a sequential standing after a part fed, the standing after that part feeds when the
+* scoring stays sequential and the part isn't the last. Other standings' consumers lose their connection.
+*/
+| {
+    type: 'set-result-scoring';
+    result: ElementId;
+    scoring: ScoringEdit | null;
+}
+/**
+* Copies elements, and folders with their content, each right after itself, the first into `section`: with what comes
+* into them and the connections among them, but not into what they feed.
+*/
+| {
+    type: 'duplicate';
+    items: FolderContentRef[];
+    section: SectionId;
+}
+/** Adds an empty group to the section: its nodes outside the groups are the new group's as well as the others'. */
+| {
+    type: 'add-group';
+    section: SectionId;
+    name: string;
+}
+/**
+* Adds copies of the group: copies of its shared nodes as their siblings, of its own nodes as the copy's own. With a
+* `classId`, the copy's class source (of the group's own) is of that class. The copies come after the groups, or in
+* `order`, all the section's groups then.
+*/
+| {
+    type: 'duplicate-group';
+    section: SectionId;
+    group: SimplifiedGroupId;
+    copies: {
+        group: SimplifiedGroupId;
+        name: string;
+        classId?: ClassId;
+    }[];
+    order?: SimplifiedGroupId[];
+}
+/** Copies the section with all its nodes into a new one right after it, linked among themselves only. */
+| {
+    type: 'copy-section';
+    section: SectionId;
+} | {
+    type: 'rename-section';
+    section: SectionId;
+    name: string;
+}
+/**
+* A new, last section. An age group section starts with its groups, each with a class source of its class, and goes
+* among the others (see `withAgeGroupsInSync`).
+*/
+| {
+    type: 'add-section';
+    section: SectionId;
+    kind: NewSectionKind;
+}
+/** Makes the class sources of the age group section's groups those of another age group. */
+| {
+    type: 'set-age-group';
+    section: SectionId;
+    classes: AgeGroupClasses;
+}
+/**
+* Turns the section into one of the kinds it can be (see `sectionConversions`). A layered section with one group
+* becomes simple without it: the group's nodes are the section's.
+*/
+| {
+    type: 'set-section-kind';
+    section: SectionId;
+    kind: SimplifiedSectionKind['type'];
+}
+/**
+* Moves the section one place up (-1) or down (1) in the order of sections, over all age group sections at once. Age
+* group sections go youngest first and aren't moved.
+*/
+| {
+    type: 'move-section';
+    section: SectionId;
+    step: -1 | 1;
+}
+/** Removes the section with all its nodes. */
+| {
+    type: 'delete-section';
+    section: SectionId;
+} | {
+    type: 'rename-group';
+    section: SectionId;
+    group: SimplifiedGroupId;
+    name: string;
+}
+/** Moves the group one place left (-1) or right (1) in the order of the section's groups. */
+| {
+    type: 'move-group';
+    section: SectionId;
+    group: SimplifiedGroupId;
+    step: -1 | 1;
+}
+/** Removes the group with its nodes; their siblings in the other groups stay. */
+| {
+    type: 'delete-group';
+    section: SectionId;
+    group: SimplifiedGroupId;
+}
+/**
+* Moves a group's own element into another group of its section: it then connects to that group's copies of shared
+* nodes, replacing what those inputs had; connections to the old group's own nodes go. A shared element becomes its
+* copy in the group alone, as that group's own: its other copies go.
+*/
+| {
+    type: 'move-to-group';
+    element: ElementId;
+    group: SimplifiedGroupId;
+}
+/**
+* Gives the element a copy in each of `groups` it isn't in yet: a group's own element becomes shared with them (see
+* `share`), a shared one gets more copies, each connected like its siblings to its group's copies of shared neighbours.
+* What a group's own nodes give it, e.g. its class source, is left to connect.
+*/
+| {
+    type: 'add-to-group';
+    element: ElementId;
+    groups: SimplifiedGroupId[];
+}
+/**
+* Makes the element of all groups one per group: a copy in each, connected like it, with what it feeds outside the
+* groups (see `splitByGroups`). A copy fed by a merger of the groups' outputs gets its group's output instead, and the
+* merger goes once it feeds nothing.
+*/
+| {
+    type: 'one-per-group';
+    element: ElementId;
+}
+/**
+* Makes the element one for all groups: a group's own element leaves its group, of a shared one the copy `element`
+* stays outside the groups and feeds what all copies fed. What came into the copies comes into it, through a new
+* `merger` where they got different things (one is picked when not given, see `LoweredFormatEditor.apply`).
+*/
+| {
+    type: 'one-for-all-groups';
+    element: ElementId;
+    merger?: StageSpec;
+}
+/** Removes the shared element's copy in `group`; the last copy left is its group's own. */
+| {
+    type: 'remove-from-group';
+    element: ElementId;
+    group: SimplifiedGroupId;
+}
+/** Takes a group's own element out of its group: it is every group's then, one node for all of them. */
+| {
+    type: 'ungroup';
+    element: ElementId;
+}
+/** The elements' nodes leave their siblings: each copy stays in its group as that group's own. */
+| {
+    type: 'unshare';
+    elements: ElementId[];
+}
+/**
+* Shares the elements' nodes, which are the groups' own: with one node of the same type per group, in the same order,
+* those become siblings; the nodes of one group get copies in the other `groups`, connected like them.
+*/
+| {
+    type: 'share';
+    elements: ElementId[];
+    groups: SimplifiedGroupId[];
+} | {
+    type: 'add-folder';
+    settings: GroupSettings;
+    parent: FolderId | null;
+    content: FolderContentRef[];
+} | {
+    type: 'update-folder';
+    folder: FolderId;
+    settings: GroupSettings;
+} | {
+    type: 'move';
+    item: FolderContentRef;
+    to: MoveTarget;
+}
+/**
+* Makes the game another one, in place: what came into it goes into the new game's inputs that fit, what it fed stays
+* connected where its outputs still are, and it keeps how it handles the disqualifications both games have.
+*/
+| {
+    type: 'change-game';
+    game: ElementId;
+    to: GameKind;
+}
+/** For game nodes and gamified formats alike; appending on gamified formats adds or updates their `Concat`. */
+| {
+    type: 'set-game-dq';
+    game: ElementId;
+    key: DqKey_2;
+    choice: CatchDqChoice;
+}
+/**
+* The steps of a stage's pipeline are the nodes of its chain. A new step goes in before the node at `index`, or after
+* the last with the chain's length. Taking a step out connects what it got to what it fed, where the types fit.
+*/
+| {
+    type: 'add-stage-step';
+    stage: ElementId;
+    index: number;
+    step: StageSpec;
+} | {
+    type: 'remove-stage-step';
+    stage: ElementId;
+    index: number;
+} | {
+    type: 'move-stage-step';
+    stage: ElementId;
+    index: number;
+    step: -1 | 1;
+} | {
+    type: 'add-comment';
+    target: ElementId;
+    text: string;
+} | {
+    type: 'update-comment';
+    comment: FormatNodeId;
+    text: string;
+};
+
+declare interface MakeValidError {
+    missingDefaultField: string;
+}
+
+declare type MathNodeOp = "addition" | "subtraction" | "multiplication" | "division-float" | "division-integer" | "modulo" | "power" | "logarithm" | "sqrt" | "absolute" | "minimum" | "maximum" | "ceil" | "floor" | "round";
+
 export declare type MergePathParams<A, B> = {
     [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never;
 };
 
+/**
+ * What a continuation does with competitors of its parts that are missing from the previous result.
+ * If the previous result is empty, nobody is missing: everyone's previous total is 0.
+ */
+declare type MissingFromPrevious = "leave-out" | "worst-total-plus-one";
+
 export declare function Modal({ children, isOpen, onClose, closable, height, width, verticalPosition, horizontalPosition, lightbox, blockBackground, }: ModalProps): null;
 
 /** Modal inner body: explicit width; shell uses `width: 'fit'` and shrink-wraps to this. */
@@ -6280,6 +6211,14 @@ export declare interface ModalConfig {
     horizontalPosition?: 'center' | 'left' | 'right';
     lightbox?: boolean;
     blockBackground?: boolean;
+    /**
+     * Opens it as a window instead: one that the user drags around by this title, that leaves the page behind it usable
+     * and that only its X closes. It stays open across navigation, so it suits content with links, such as errors
+     * pointing at what caused them. Ignores the options about size, position and background.
+     */
+    window?: {
+        title: ReactNode;
+    };
     onClose?: () => void;
 }
 
@@ -6307,8 +6246,38 @@ export declare interface ModalProps {
     blockBackground?: boolean;
 }
 
+/**
+ * Where a moved item goes: right before another item, into that item's folder, or last into a folder. The view orders
+ * items by their position, so the moved nodes get a position between their new neighbours.
+ */
+declare type MoveTarget = {
+    type: 'before';
+    item: FolderContentRef;
+} | {
+    type: 'first' | 'last';
+    folder: FolderId | null;
+};
+
+declare type MultiplexingStrategy = "serpentine" | "round-robin";
+
+declare type MultiplexingStrategy_2 = components['schemas']['MultiplexingStrategy'];
+
+declare type NewSectionKind = {
+    type: 'simple' | 'layered';
+} | {
+    type: 'age-group';
+    classes: AgeGroupClasses;
+};
+
+declare type NodeConfigurationError = { type: "extract-record-field-error"; data: ExtractRecordFieldError<Primitive> } | { type: "invalid-value"; data: { identifier: string; message: string; givenValue: Value<SerializableNonPrimitiveValue> } } | { type: "node-is-not-variadic-but-vargs-to-array-set" } | { type: "found-closure-input-node-in-non-closure" } | { type: "invalid-node" } | { type: "illegal-vargs-to-array" } | { type: "illegal-control-values" };
+
 declare type NodeInstanceHash = Brand<string, 'nodeInstanceHash'>;
 
+/**
+ * Shared by the variants of one node, each in another group of the same section.
+ */
+declare type NodeLinkId = string & { readonly __brand: 'nodeLinkId' };
+
 /**
  * Function-like type for a node: generic parameters, inputs, outputs, and defaults.
  * Written in notation as `<T>(T) -> (T)` for the identity node.
@@ -6360,6 +6329,13 @@ export declare interface NodeSignature<T, R = ParamRef> {
     requiredTags: number[];
 }
 
+declare type NodetyError = { type: "NodeHasChildren" } | { type: "ParentNotFound" } | { type: "NodeNotFound" } | { type: "CycleDetected" } | { type: "TypeExprValidationError"; error: TypeExprValidationError };
+
+declare type NodeType = { type: "input" } | { type: "output" } | { type: "format"; data: { formatId: FormatId; catchDqs?: Record<DqKey, DqStrategy> } } | { type: "math"; data: { op: MathNodeOp } } | { type: "game"; data: GameNodeDTO } | { type: "output-table" } | { type: "input-table"; data: { tableId: TableId } } | { type: "portal"; data: { sourceNodeId: FormatNodeId; sourceOutput: OutputIdx } } | { type: "class"; data: { classId: ClassId } } | { type: "disqualify"; data: DisqualifyNode } | { type: "group"; data: GroupNode } | { type: "string-concat" } | { type: "string-format" } | { type: "sort-node" } | { type: "constant" } | { type: "merge-tables" } | { type: "divide-table" } | { type: "distribute-table" } | { type: "split-table"; data: SplitTableNode } | { type: "concat"; data: { sorted: boolean } } | { type: "remove-places" } | { type: "table-map" } | { type: "length" } | { type: "boolean-op"; data: { op: BooleanOp } } | { type: "record-field"; data: { op: RecordFieldOp } } | { type: "add-record-fields"; data: AddRecordFieldsNode } | { type: "fallback" } | { type: "gt-row"; data: { errorOnNotFound: boolean } } | { type: "filter-gt"; data: { filter: GTFilterKind } } | { type: "comparison"; data: { op: ComparisonOp } } | { type: "comment"; data: { comment: string; linkedNodeId?: FormatNodeId } } | { type: "ternary" } | { type: "separate-row" } | { type: "update-row" } | { type: "array-map" } | { type: "create-array" } | { type: "create-table" } | { type: "array-access"; data: { errorOnNotFound: boolean } } | { type: "unpack-array"; data: { errorOnNotFound: boolean } } | { type: "promotion-relegation"; data: { finalCount: number | null } } | { type: "age-at" } | { type: "split-by-class"; data: { classCount: number } } | { type: "invalid"; data: { nodeType: NodeType } } | { type: "empty-record" } | { type: "event-competitors"; data: EventCompetitorsNode } | { type: "add-columns"; data: AddColumnsNode } | { type: "matrix-transpose" } | { type: "simple-scoring"; data: SimpleScoringNode } | { type: "classes-competitors"; data: ClassesCompetitorsNode };
+
+/** A change of a node's settings: its node type and its data, the values of its inputs or its number of variadic ports. */
+declare type NodeUpdate = Partial<Pick<FormatNodeDTO_2, 'nodeType' | 'controlValues' | 'addedInputVargs' | 'addedOutputVargs'>>;
+
 declare type NoMetadata = Record<never, never>;
 
 declare interface NoSupertypeLayer<T> {
@@ -6409,7 +6385,7 @@ export declare interface OptionalQueryField<T> {
     codec: QueryCodec<T>;
 }
 
-declare type OutputIdx = Brand<number, 'outputIdx'>;
+declare type OutputIdx = number & { readonly __brand: 'outputIdx' };
 
 export declare const Page: FC<PageProps>;
 
@@ -6433,6 +6409,8 @@ export declare interface ParamRef {
     infer: boolean;
 }
 
+declare type ParentType = { type: "format-root" } | { type: "closure-node"; data: FormatNodeId };
+
 export declare interface ParsedQuery<Values> {
     values: Values;
     /** The original search with malformed known values removed and valid values normalized. */
@@ -6440,6 +6418,8 @@ export declare interface ParsedQuery<Values> {
     malformedKeys: string[];
 }
 
+declare type ParseErrorKind = { type: "invalid-token" } | { type: "unexpected-token" } | { type: "expected-token"; data: { expected: string } } | { type: "invalid-number" } | { type: "unterminated-string" };
+
 export declare type PathParams<Path extends string> = Path extends `${infer Base}/*` ? PathParams<Base> : Path extends `${infer _}/${infer Rest}` ? MergePathParams<PathSegmentParam<_>, PathParams<Rest>> : PathSegmentParam<Path>;
 
 export declare type PathSegmentParam<S extends string> = S extends `:${infer P}` ? {
@@ -6507,6 +6487,12 @@ export declare function putTableRows(workspaceId: CommonWorkspaceId, eventId: Ev
     } | {
         type: "row-not-hidden";
         data: [components["schemas"]["TableId"], components["schemas"]["CompetitorId"]];
+    } | {
+        type: "incompatible-row";
+        data: components["schemas"]["MakeValidError"];
+    } | {
+        type: "change-would-modify-rows";
+        data: components["schemas"]["RecordModifications"];
     };
 }>;
 
@@ -6540,6 +6526,13 @@ export declare interface QuerySchema<Fields extends QueryFields> {
     set<Key extends keyof Fields>(search: string, key: Key, value: QueryFieldValue<Fields[Key]>): string;
 }
 
+declare type RecordFieldOp = "read-field" | "write-field";
+
+declare interface RecordMakeValidMutation {
+    columnName: string;
+    newValue: Value;
+}
+
 /**
  * RecordTypes should **only** be manipulated though this helper to have a single source of truth for the structure.
  */
@@ -6600,9 +6593,10 @@ export declare interface RouterContextType {
     /** The complete reactive browser location. */
     location: RouterLocation;
     /**
-     * User initiated routing. Asks route guards before leaving (see `useGuardRoute`).
+     * User initiated routing. Asks route guards before leaving (see `useGuardRoute`). `onArrive` runs once the location
+     * is `to`, also when it already was, and not when the user stays on a guarded route.
      */
-    navigate: (to: string) => void;
+    navigate: (to: string, onArrive?: (location: RouterLocation) => void) => void;
     /**
      * Programmatic redirect replacing the current history entry. Bypasses route guards.
      */
@@ -6644,6 +6638,18 @@ export declare interface RowAction<T> {
 
 declare type RowMutationIdx = Brand<number, 'rowMutationIdx'>;
 
+declare type RowMutationKind = { type: "set-record-field"; field: string; value: Value } | { type: "push-unranked"; columns: RecordValue<Primitive> } | { type: "remove" } | { type: "set-place"; place: number } | { type: "set-unranked"; tiebraker: number } | { type: "set-place-and-tie-braker"; place: number; tiebraker: number };
+
+declare interface RowMutationWithBatch {
+    kind: RowMutationKind;
+    competitorId: number;
+    /**
+     * When performing batch actions like delete all, then all these will have the same batch id.
+     * Otherwise it will get incremented. Used for undo & redo.
+     */
+    batch: number;
+}
+
 declare interface Rows<SortingState> {
     /**
      * Competitors are guaranteed to be unique per game table.
@@ -6663,16 +6669,50 @@ export declare enum RowState {
     Added = 3
 }
 
-export declare function SearchInput({ value, onChange, placeholder, className }: SearchInputProps): JSX.Element;
+/**
+ * GameTableTypes types should **only** be manipulated though this helper to have a single source of truth for the structure.
+ */
+declare interface RowTypeHelper<R = ParamRef> {
+    columns: RecordTypeHelper<R>;
+}
+
+declare type RuntimeErrorKind = { type: "division-by-zero" } | { type: "variable-not-found"; data: { name: string } } | { type: "function-not-found"; data: { name: string } } | { type: "index-out-of-bounds" } | { type: "invalid-index" } | { type: "invalid-math-operands" } | { type: "non-boolean-condition" } | { type: "non-boolean-operand" } | { type: "invalid-comparison-operands" } | { type: "argument"; data: { expected: string; got: string } };
+
+/** A sequential scoring of fewer than two parts is a parallel one (see `ResultScoring`). */
+declare interface ScoringEdit {
+    mode: ScoringMode;
+    parts: {
+        part: SimpleScoringPart_2;
+        from: number | null;
+    }[];
+}
+
+declare type ScoringMode = {
+    type: 'parallel';
+} | {
+    type: 'sequential';
+    missing: MissingFromPrevious;
+};
+
+export declare function SearchInput({ value, onChange, placeholder, className, autoFocus, ref, onKeyDown }: SearchInputProps): JSX.Element;
 
 export declare type SearchInputProps = {
     value: string;
     onChange: (value: string) => void;
     placeholder?: string;
     className?: string;
+    autoFocus?: boolean;
+    ref?: Ref<HTMLInputElement>;
+    onKeyDown?: (event: KeyboardEvent_2<HTMLInputElement>) => void;
 };
 
-declare type SerializableNonPrimitiveValue = { type: "game-table"; data: Table<Unsorted_2, StateMetadata> } | { type: "game-table-sorted"; data: Table<Sorted_2, StateMetadata> } | { type: "row"; data: Row } | { type: "class"; data: string } | { type: "closure" };
+/**
+ * A section of the simplified view (see `SimplifiedView`). Until it is stored, a section is identified by the lowest
+ * node id of its island, which is a uuid like the ids of stored sections.
+ */
+declare type SectionId = SimplifiedSectionId;
+
+declare type SerializableNonPrimitiveValue = { type: "game-table"; data: Table<Unsorted, StateMetadata> } | { type: "game-table-sorted"; data: Table<Sorted, StateMetadata> } | { type: "row"; data: Row } | { type: "class"; data: string } | { type: "closure" };
 
 /**
  * A keyboard shortcut as the keys to press together, e.g. `['Mod', 'Shift', 'Z']`. `Mod` is Ctrl, or
@@ -6682,10 +6722,10 @@ declare type SerializableNonPrimitiveValue = { type: "game-table"; data: Table<U
 export declare type Shortcut = readonly string[];
 
 /**
- * Shows a dialog that can be dismissed (ESC, click outside, or X button)
+ * Shows a dialog that can be dismissed (ESC, click outside, or X button; only X for a window)
  * Returns the selected value or null if dismissed
  */
-export declare function showDialog<T>(modal: ModalControls, buttons: DialogButton<T>[], content: ReactNode): Promise<T | null>;
+export declare function showDialog<T>(modal: ModalControls, buttons: DialogButton<T>[], content: ReactNode, { window }?: DialogOptions): Promise<T | null>;
 
 /**
  * A panel as a column of its own, next to the content. Keeping it out of the content gives toolbars the whole
@@ -6746,7 +6786,69 @@ export declare type SidePanelIcon = ComponentType<SVGProps<SVGSVGElement>>;
 
 export declare type SidePanelVariant = 'dock' | 'drawer';
 
-declare type Sorted = Brand<'sorted', 'sorted'>;
+/**
+ * Place 1 = 1 point, Place 2 = 2 points, etc.
+ * On tie, whoever won the part with the highest priority wins.
+ * If still tied, the next lower priority part is considered etc.
+ *
+ * ```text
+ * (Table<{}, Sorted>, ...) -> (Table<{total_points: Integer, <part name>: Integer, ...}, Sorted>)
+ * ```
+ *
+ * One input per part and one output table, sorted by ascending total points.
+ * Competitors are the union of all parts: a competitor without a place in a part
+ * (missing from the table of that part, or in it without a place) scores one point
+ * more than that part has rows, so not finishing a part is always worse than
+ * finishing it last. An empty part has not taken place yet and scores 0 for everyone.
+ *
+ * With `continues_previous`, the first input is the result of a previous scoring,
+ * `Table<{total_points: Integer}, Sorted>`, and the totals add this node's parts to the previous `total_points`.
+ * The previous result's other columns are carried over, those named like a part are replaced. Ties keep the
+ * previous result's order.
+ */
+declare interface SimpleScoringNode {
+    parts: SimpleScoringPart[];
+    /**
+     * Missing means a scoring that continues none, so that nodes written before keep their serialization.
+     */
+    continuesPrevious?: MissingFromPrevious;
+}
+
+/**
+ * One scored part, e.g. a single race of a series.
+ */
+declare interface SimpleScoringPart {
+    /**
+     * Used as the name of the output column holding the points of this part.
+     */
+    name: string;
+    /**
+     * Higher priority parts break ties first.
+     */
+    priority: number;
+}
+
+declare type SimpleScoringPart_2 = components['schemas']['SimpleScoringPart'];
+
+/**
+ * Unique per format, not only per section.
+ */
+declare type SimplifiedGroupId = string & { readonly __brand: 'simplifiedGroupId' };
+
+declare type SimplifiedSectionId = string & { readonly __brand: 'simplifiedSectionId' };
+
+/** A `simple` section has no groups. An age group's classes are the values of its two groups' class sources, see `ageGroupOf`. */
+declare type SimplifiedSectionKind = {
+    type: 'layered';
+} | {
+    type: 'simple';
+} | {
+    type: 'age-group';
+    data: {
+        female: SimplifiedGroupId;
+        male: SimplifiedGroupId;
+    };
+};
 
 /**
  * Sorted game tables have the following guarantees:
@@ -6758,12 +6860,64 @@ declare type Sorted = Brand<'sorted', 'sorted'>;
  * - 1, 2, 2, 2, 5, None, None
  * - None, None
  */
-declare type Sorted_2 = null;
+declare type Sorted = null;
+
+declare type SourceKind = {
+    type: 'class';
+    classId: ClassId;
+} | {
+    type: 'event-competitors';
+    competitorType: CompetitorType;
+} | {
+    type: 'classes-competitors';
+} | {
+    type: 'input-table';
+    tableId: TableId;
+};
+
+/**
+ * 1-based line and column at the start of a token.
+ */
+declare interface SourceLocation {
+    line: number;
+    column: number;
+}
+
+/**
+ * Splits a sorted table at the given places, see `Table::split_n`.
+ *
+ * for `Static { split_count }`:
+ * ```text
+ * <C extends {}>(Table<C, Sorted>, Integer * split_count) -> (Table<C, Sorted> * (split_count + 1))
+ * ```
+ * for `Dynamic`:
+ * ```text
+ * <C extends {}>(Table<C, Sorted>, Array<Integer>) -> (Array<Table<C, Sorted>>)
+ * ```
+ */
+declare type SplitTableNode = { type: "static"; data: { splitCount: number } } | { type: "dynamic" };
+
+/** The node of a new stage. Inputs without a value get their default. */
+declare type StageSpec = Pick<FormatNodeDTO_2, 'nodeType'> & Partial<Pick<FormatNodeDTO_2, 'inputVargsToArray' | 'outputVargsToArray' | 'controlValues'>>;
 
 declare interface StateMetadata {
     state: TableState;
 }
 
+declare interface Step {
+    /**
+     * Whoever ran the operation, see [Origin::attributed]: the engine's `NodeInstanceHash`, a raw uuid because this
+     * crate doesn't know engine types. None until it is attributed.
+     */
+    node: string | null;
+    op: StepOp;
+}
+
+/**
+ * An operation that moved rows between or within tables.
+ */
+declare type StepOp = "create" | "sort" | "split" | "concat" | "merge" | "divide" | "filter" | "remove-places" | "set-places" | "promote-relegate" | "score";
+
 export declare enum StorageType {
     Session = 0,
     Local = 1
@@ -6793,7 +6947,18 @@ export declare type TableDropTarget = EventPath & {
     table: TableDAO;
 };
 
-export declare type TableId = Brand<string, 'tableId'>;
+/**
+ * Identifies a table, the primary key of `tables`. Comes from one of:
+ * - [Self::new_random]: a table the user adds. The endpoint picks the id and the mutation carries it.
+ * - [Self::of_user_game]: the entry and result table of a game of the user.
+ * - [Self::of_game] and [Self::of_node]: a table of a node, see [TableDAO::derived_id]. Executing a graph creates the
+ *   same ids every time.
+ * - [TableDAO::keep_as_user_copy]: a table of a node that the user kept when the node instance got deleted.
+ *
+ * Deserializing one only yields a reference to an existing table; it does not check that it exists or how it was
+ * made. Changing a derivation changes what replaying a log produces and needs an `ENGINE_VERSION` increment.
+ */
+export declare type TableId = string & { readonly __brand: 'tableId' };
 
 export declare interface TableProps<TData extends RowData> {
     data: TData[];
@@ -6802,6 +6967,7 @@ export declare interface TableProps<TData extends RowData> {
     allowSelect?: boolean;
     getRowId?: (row: TData, index: number) => string;
     getRowState?: (row: TData) => RowState;
+    getRowClassName?: (row: TData) => string | undefined;
     rowClicked?: (row: TData) => void;
     /**
      * Route a row leads to. Clicking the row routes there (after `rowClicked`); a middle or Ctrl click
@@ -6829,6 +6995,11 @@ export declare interface TableProps<TData extends RowData> {
      * Columns with `enableHiding: false` are excluded.
      */
     columnVisibility?: [ColumnVisibilityState, OnChangeFn<ColumnVisibilityState>];
+    /**
+     * Shows a search box above the table that finds rows by the text of their visible columns, and a search per
+     * column in its header. See `AppTableColumnMeta.searchText`.
+     */
+    enableSearch?: boolean;
 }
 
 export declare type TableSortedDTO = components['schemas']['Table_for_Sorted_and_StateMetadata'];
@@ -6853,6 +7024,21 @@ export declare interface TimeDeltaInputProps {
 
 export { toast }
 
+/**
+ * One way a row got to where it is.
+ */
+declare interface Trail {
+    /**
+     * The persisted table the row was read from: the engine's `TableId`, a raw uuid like [Step::node]. None for rows
+     * that were created from scratch.
+     */
+    checkpoint: string | null;
+    /**
+     * The operations since the checkpoint, in order.
+     */
+    steps: Step[];
+}
+
 export declare type Type = { type: "integer"; data: { min: number | null; max: number | null } } | { type: "float" } | { type: "string"; data: string | null } | { type: "boolean" } | { type: "iterable" } | { type: "countable" } | { type: "comparable" } | { type: "sortable" } | { type: "unit" } | { type: "time-delta" } | { type: "date-time" } | { type: "date" } | { type: "primitive" } | { type: "competitor-id" } | { type: "array" } | { type: "record" } | { type: "table" } | { type: "row" } | { type: "table-sorting"; data: TableSorting } | { type: "class" };
 
 /**
@@ -6869,6 +7055,15 @@ export declare interface TypeContext {
     returnType: TypeExpr<Type, ParamRef>;
 }
 
+declare interface TypeError_2 {
+    kind: TypeErrorKind;
+    location: SourceLocation;
+}
+
+declare type TypeErrorKind = { type: "unknown-variable"; data: { name: string } } | { type: "unknown-function"; data: { name: string } } | { type: "wrong-arity"; data: { name: string; expected: number; got: number } } | { type: "type-mismatch"; data: { expected: string; got: string } } | { type: "non-integer-index" } | { type: "non-record-property-access" } | { type: "nodety"; data: { message: string } };
+
+declare type TypeErrors = TypeError_2[];
+
 /**
  * Type expression—the core type representation in nodety.
  *
@@ -6882,6 +7077,11 @@ export declare type TypeExpr<T, R = ParamRef> = { type: "Type"; data: T } | { ty
 
 declare type TypeExprValidationError = { type: "UnknownVar"; var: LocalParamID } | { type: "CyclicReference" };
 
+/**
+ * Type hints for pre-inference annotations (e.g. `T = Integer, U = String`).
+ */
+declare type TypeHints<T, R = ParamRef> = Record<LocalParamID, TypeExpr<T, R>>;
+
 export declare interface TypeOperators { graphite: [Type, ArithmeticOperator] }
 
 export declare interface TypeOperators {}
@@ -6907,13 +7107,11 @@ export declare interface TypeParameter<T, R = ParamRef> {
  */
 export declare type TypeParameters<T, R = ParamRef> = Record<LocalParamID, TypeParameter<T, R>>;
 
-declare type Unsorted = Brand<'unsorted', 'unsorted'>;
-
 /**
  * The places of unsorted game can be arbitrary values in arbitrary order.
  * Dublicated places are allowed. However competitors must still be unique.
  */
-declare type Unsorted_2 = null;
+declare type Unsorted = null;
 
 /** The engine's active locale. Extensions ship their own dictionaries and select them by it. */
 export declare function useEngineLocale(): Locales;
@@ -6921,9 +7119,16 @@ export declare function useEngineLocale(): Locales;
 /** Returns a `fetch` for `path` (relative, e.g. `"items"`) on the calling extension's own backend in the current event. */
 export declare function useExtensionBackend(): ExtensionHost['backend'];
 
-/** The identifier the calling extension is installed under, e.g. the key of its `extensionData`. */
+/** The identifier the calling extension is installed under, e.g. the key of its `customData`. */
 export declare function useExtensionIdentifier(): string;
 
+/**
+ * A preference of the calling extension, stored as `ext:<identifier>/<key>` like the engine's own: per user on root,
+ * per server on self-hosted. The value is stored as JSON; `isValid` checks what was stored, `defaultValue` is used
+ * until the preferences are loaded and when the key is unset or the stored value isn't valid.
+ */
+export declare function useExtensionPreference<T>(key: string, defaultValue: T, isValid: (stored: unknown) => stored is T): [T, (value: T) => void];
+
 export declare function useMediaQuery(query: string): boolean;
 
 export declare function useModal(): ModalControls;
@@ -6936,9 +7141,10 @@ export declare function useModal(): ModalControls;
  *
  * @param storageKey Key used for persisting the state. Only the key passed
  *                   in the to the first call of usePersistedState is used. Consequent keys are discarded.
+ *                   Null keeps the state in memory only, like useState.
  * @param initialState The initial state. Equal to useStates initial value
  */
-export declare function usePersistedState<S>(storageKey: string, initialState: S | (() => S), { storage: storageType, version }?: PersistedStateOptions): [S, (newState: S | ((prev: S) => S)) => void];
+export declare function usePersistedState<S>(storageKey: string | null, initialState: S | (() => S), { storage: storageType, version }?: PersistedStateOptions): [S, (newState: S | ((prev: S) => S)) => void];
 
 /** Hook to use the router context. Must be called within a <Router> provider. */
 export declare function useRouter(): RouterContextType;
@@ -6949,8 +7155,9 @@ export declare function useRouter(): RouterContextType;
  */
 export declare function useRunLogBatch(): (workspaceId: CommonWorkspaceId, operations: LogOperation[], label: ReactNode) => Promise<boolean | null>;
 
-/** The `:` params that are uuids, by name. All other `:` params are numbers. */
+/** The `:` params that are uuids, by name. All other `:` params are numbers. Workspace ids are uuids on root only. */
 declare type UuidPathParams = {
+    workspaceId: CommonWorkspaceId;
     classId: ClassId;
     eventId: EventId;
     formatId: FormatId;
@@ -6976,6 +7183,10 @@ declare interface ValidationError<T> {
 
 declare type ValidationErrorKind<T> = { type: "TypeParameterBoundsExceeded" } | { type: "TagMissing"; data: number[] } | { type: "MultipleEdgesOnOneInput" } | { type: "EdgeMissingOnInput" } | { type: "EdgeHasNoSourceOutput" } | { type: "InsufficientlyInferredTypes" } | { type: "NonPortTypesIO" } | { type: "TypeExprValidationError"; data: TypeExprValidationError } | { type: "TypeMismatch"; data: DetailedSupertypeDiagnostics<T> };
 
+/**
+ * # Important
+ * Changes in here are breaking changes for logs
+ */
 export declare type Value<T = Primitive> = { type: "unit" } | { type: "float"; data: number } | { type: "integer"; data: number } | { type: "string"; data: string } | { type: "boolean"; data: boolean } | { type: "array"; data: ArrayValue<T> } | { type: "record"; data: RecordValue<T> } | { type: "time-delta"; data: [number, number] } | { type: "date-time"; data: string } | { type: "date"; data: string } | { type: "non-primitive"; data: T };
 
 /**
@@ -6997,7 +7208,7 @@ export declare type WorkingGameDTO = Omit<GameDTO, 'gameFormatId'> & {
     gameFormatId: GameFormatId | null;
 };
 
-export declare type WorkspaceRootId = Brand<number, 'workspaceRootId'>;
+export declare type WorkspaceRootId = Brand<string, 'workspaceRootId'>;
 
 export declare type WorkspaceSelfHostedId = Brand<number, 'workspaceSelfHostedId'>;