@graphite-sports/sdk 0.1.0 → 0.2.0

package/index.d.ts

@@ -1,34 +1,221 @@
 import { ChangeEventHandler } from 'react';
+import { ColumnDef } from '@tanstack/react-table';
+import { ColumnHelper } from '@tanstack/table-core';
+import { ComponentProps } from 'react';
+import { CSSProperties } from 'react';
 import type { DataTag } from '@tanstack/react-query';
-import type { FC } from 'react';
+import { FC } from 'react';
 import { FocusEventHandler } from 'react';
 import { HTMLInputTypeAttribute } from 'react';
 import { JSX } from 'react/jsx-runtime';
 import { KeyboardEventHandler } from 'react';
+import { default as React_2 } from 'react';
+import * as React_3 from 'react';
 import { ReactNode } from 'react';
 import type { Ref } from 'react';
 import { RefObject } from 'react';
+import { RowData } from '@tanstack/react-table';
+import { RowModel } from '@tanstack/table-core';
+import { SortingState } from '@tanstack/react-table';
+import { Tab } from '@headlessui/react';
+import { TabGroup } from '@headlessui/react';
+import { Table as Table_2 } from '@tanstack/table-core';
+import { TableFeature } from '@tanstack/table-core';
+import { TabList } from '@headlessui/react';
+import { TabPanel } from '@headlessui/react';
+import { TabPanels } from '@headlessui/react';
 import { toast } from 'react-hot-toast';
 import type { UnusedSkipTokenOptions } from '@tanstack/react-query';
 
-declare type AnyQuerySchema = QuerySchema<QueryFields>;
+export declare type AnyQuerySchema = QuerySchema<QueryFields>;
 
-export declare function AppButton({ type, onClick, disabled: disabledProp, mutates, children, submit, className, loading, value, ref, href, }: Props): JSX.Element;
+export declare function AppButton({ type, onClick, disabled: disabledProp, mutates, children, submit, className, loading, value, ref, href, }: AppButtonProps): JSX.Element;
 
-declare type AppButtonType = 'primary' | 'secondary' | 'danger';
+export declare type AppButtonProps = {
+    type?: AppButtonType;
+    onClick?: () => void;
+    disabled?: boolean;
+    /** Disabled while read-only (see `useIsReadonly`). */
+    mutates?: boolean;
+    children?: ReactNode;
+    submit?: boolean;
+    className?: string;
+    loading?: boolean;
+    value?: string;
+    ref?: RefObject<HTMLButtonElement | null>;
+    /** Makes the button a link to this route, so it can also be opened in a new tab. `onClick` runs before routing. */
+    href?: string;
+};
+
+export declare type AppButtonType = 'primary' | 'secondary' | 'danger';
+
+export declare function AppCheckbox(props: AppCheckboxProps): JSX.Element;
+
+export declare type AppCheckboxProps = {
+    checked: boolean;
+    onChange?(checked: boolean): void;
+    name?: string;
+    disabled?: boolean;
+    tabIndex?: number;
+    label?: string | React_2.ReactNode;
+    description?: string | React_2.ReactNode;
+    stopPropagation?: boolean;
+    readonly?: boolean;
+};
+
+export declare function AppDisclosure({ header, children, className, defaultOpen, transition, chevron, }: AppDisclosureProps): JSX.Element;
+
+export declare type AppDisclosureProps = {
+    header: ReactNode;
+    children: ReactNode;
+    className?: string;
+    defaultOpen?: boolean;
+    transition?: boolean;
+    chevron?: boolean;
+};
 
 export declare const AppInput: {
-    ({ ref, inputRef, ...props }: Props_2 & {
+    ({ ref, inputRef, ...props }: AppInputProps & {
         ref?: React.RefObject<HTMLInputElement | null>;
     }): JSX.Element;
     displayName: string;
 };
 
-declare type ArithmeticOperator = "add" | "subtract";
+export declare type AppInputProps = {
+    label?: string;
+    description?: string;
+    value?: string;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    onBlur?: FocusEventHandler<HTMLInputElement>;
+    onFocus?: FocusEventHandler<HTMLInputElement>;
+    onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
+    type?: HTMLInputTypeAttribute;
+    placeholder?: string;
+    required?: boolean;
+    maxLength?: number;
+    pattern?: string;
+    disabled?: boolean;
+    className?: string;
+    tabIndex?: number;
+    readonly?: boolean;
+    layout?: InputLayout;
+    inputRef?: React.RefObject<HTMLInputElement | null>;
+    endAdornment?: ReactNode;
+    autoFocus?: boolean;
+};
+
+export declare function AppListbox<TVal>({ options, value, onChange, label, description, disabled, placeholder, className, direction, readonly: readonlyProp, required, }: AppListboxProps<TVal>): JSX.Element;
+
+export declare type AppListboxProps<TVal> = {
+    options: Option_2<TVal>[];
+    value?: TVal;
+    onChange?: (value: TVal) => void;
+    label?: React_2.ReactNode;
+    description?: React_2.ReactNode;
+    placeholder?: React_2.ReactNode;
+    disabled?: boolean;
+    className?: string;
+    direction?: 'up' | 'down';
+    readonly?: boolean;
+    required?: boolean;
+};
+
+export declare function AppNumberInput<IsRequired extends boolean = false>({ label, description, value, onChange, min, max, integer, placeholder, required, disabled, readonly: readonlyProp, className, layout, onKeyDown, onFocus, onBlur, tabIndex, autoFocus, inputRef, }: AppNumberInputProps<IsRequired>): JSX.Element;
+
+export declare type AppNumberInputProps<IsRequired extends boolean = false> = {
+    label?: string;
+    description?: string;
+    min?: number | null;
+    max?: number | null;
+    integer?: boolean;
+    placeholder?: string;
+    required?: IsRequired;
+    disabled?: boolean;
+    readonly?: boolean;
+    className?: string;
+    layout?: InputLayout;
+    value?: NullableUnlessRequired<number, IsRequired>;
+    onChange?: (value: NullableUnlessRequired<number, IsRequired>) => void;
+    onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
+    onFocus?: FocusEventHandler<HTMLInputElement>;
+    onBlur?: FocusEventHandler<HTMLInputElement>;
+    tabIndex?: number;
+    autoFocus?: boolean;
+    inputRef?: React.RefObject<HTMLInputElement | null>;
+};
+
+export declare function AppSwitch(props: AppSwitchProps): JSX.Element;
+
+export declare type AppSwitchProps = {
+    checked?: boolean;
+    onChange?(checked: boolean): void;
+    name?: string;
+    disabled?: boolean;
+    tabIndex?: number;
+    label?: string | React_2.ReactNode;
+    description?: string | React_2.ReactNode;
+    className?: string;
+    readonly?: boolean;
+};
+
+export declare function AppTab({ className, ...props }: ComponentProps<typeof Tab>): JSX.Element;
 
-declare type ArrayValue<T = Primitive> = Value<T>[];
+export declare function AppTabGroup(props: ComponentProps<typeof TabGroup>): JSX.Element;
 
-declare type BIB = Brand<number, 'bib'>;
+export declare function AppTable<TData extends RowData>({ data, columns, actions, allowSelect, getRowId, getRowState, rowClicked, rowHref, initialPageSize, initialSorting, pageSizes, enableSorting, autoResetPageIndex, emptyTableText, columnVisibilityStorageKey, }: TableProps<TData>): JSX.Element;
+
+export declare type AppTableFeatures = typeof appTableFeatures;
+
+/**
+ * The single feature registry every `AppTable` instance uses. Shared so callers can build their
+ * `ColumnDef`s against the same `TFeatures` via {@link createAppTableColumnHelper}.
+ */
+export declare const appTableFeatures: {
+    columnSizingFeature: TableFeature;
+    rowSelectionFeature: TableFeature;
+    rowSortingFeature: TableFeature;
+    sortedRowModel: (table: Table_2<any, any>) => () => RowModel<any, any>;
+    rowPaginationFeature: TableFeature;
+    paginatedRowModel: (table: Table_2<any, any>) => () => RowModel<any, any>;
+    columnVisibilityFeature: TableFeature;
+};
+
+export declare function AppTabList({ className, ...props }: ComponentProps<typeof TabList>): JSX.Element;
+
+export declare function AppTabPanel({ className, ...props }: ComponentProps<typeof TabPanel>): JSX.Element;
+
+export declare function AppTabPanels(props: ComponentProps<typeof TabPanels>): JSX.Element;
+
+/**
+ * A tooltip that costs nothing until it is pointed at.
+ *
+ * `TooltipPrimitive.Root` pulls in around nine components - the tooltip and portal providers,
+ * the popper, its anchor, the trigger and a presence wrapper - and mounts all of them whether or
+ * not the tooltip will ever be shown. A node graph puts hundreds of tooltips on screen at once,
+ * where that machinery dominated every render of the editor. So until the pointer or the
+ * keyboard reaches the trigger, only `children` is mounted; the first hover or focus arms the
+ * real tooltip and gets replayed onto it.
+ */
+export declare function AppTooltip({ children, content, side, open, defaultOpen, onOpenChange, className, shortcut, ...props }: AppTooltipProps): JSX.Element;
+
+export declare interface AppTooltipProps {
+    children: React_3.ReactNode;
+    content: React_3.ReactNode;
+    /** The keys that do what the trigger does, shown after `content`. */
+    shortcut?: Shortcut;
+    /** Preferred side of the trigger to render against. Defaults to "top". */
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    className?: string;
+}
+
+export declare type ArithmeticOperator = "add" | "subtract";
+
+export declare type ArrayValue<T = Primitive> = Value<T>[];
+
+export declare type BIB = Brand<number, 'bib'>;
 
 /**
  * Mirrors the backend's `domain_id!` newtype IDs (graphite-engine/src/domain_id.rs) so distinct ID
@@ -36,10 +223,13 @@ declare type BIB = Brand<number, 'bib'>;
  * `#/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`.
  */
-declare type Brand<T, B> = T & {
+export declare type Brand<T, B> = T & {
     readonly __brand: B;
 };
 
+/** 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: {
     '/': undefined;
     '/download': undefined;
@@ -142,7 +332,7 @@ export declare type ClassDAO = components['schemas']['ClassDAO'];
 
 export declare type ClassId = Brand<number, 'classId'>;
 
-declare type ClassResponse = components['schemas']['ClassResponse'];
+export declare type ClassResponse = components['schemas']['ClassResponse'];
 
 declare type CommonApiKeyId = Brand<number, 'commonApiKeyId'>;
 
@@ -152,7 +342,42 @@ export declare type CompetitorDAO = components['schemas']['CompetitorDAO'];
 
 export declare type CompetitorId = Brand<number, 'competitorId'>;
 
-declare type CompetitorType = components['schemas']['CompetitorType'];
+export declare type CompetitorInTeamDAO = components['schemas']['CompetitorInTeamDAO'];
+
+export declare function competitorLabel(competitorsById: ReadonlyMap<CompetitorId, CompetitorDAO>, competitorId: CompetitorId | null): string;
+
+export declare const CompetitorNameLineSpacer: FC<{
+    className?: string;
+}>;
+
+/**
+ * Shows which competitor is picked and lets the user pick another one.
+ */
+export declare function CompetitorSelector<IsRequired extends boolean = false>({ value, onChange, onBlurChange, required, competitorsMapped, disabled, placeholder, className, inputClassName, forbiddenCompetitorsRef, }: CompetitorSelectorProps<IsRequired>): JSX.Element;
+
+export declare type CompetitorSelectorProps<IsRequired extends boolean = false> = {
+    value: NullableUnlessRequired<CompetitorId, IsRequired>;
+    onChange?: (value: NullableUnlessRequired<CompetitorId, IsRequired>) => void;
+    /**
+     * Called when a competitor is picked from the menu.
+     */
+    onBlurChange?: (value: NullableUnlessRequired<CompetitorId, IsRequired>) => void;
+    required?: IsRequired;
+    competitorsMapped: CompetitorsMapped;
+    disabled?: boolean;
+    placeholder?: string;
+    className?: string;
+    inputClassName?: string;
+    onEnterKey?: () => void;
+    forbiddenCompetitorsRef?: RefObject<Set<CompetitorId>>;
+};
+
+export declare interface CompetitorsMapped {
+    byId: Map<CompetitorId, CompetitorDAO>;
+    byBib: Map<BIB, CompetitorDAO>;
+}
+
+export declare type CompetitorType = components['schemas']['CompetitorType'];
 
 declare interface components {
     schemas: {
@@ -1323,7 +1548,9 @@ declare interface components {
             kind: components["schemas"]["ExtensionKind"];
         };
         /** @enum {string} */
-        ExtensionError: "local-extension-not-found" | "failed-to-resolve-extension";
+        ExtensionError: "local-extension-not-found" | "failed-to-resolve-extension" | "failed-to-start" | "invalid-identifier" | "crashed";
+        /** @description A single path segment on every platform without control characters, so it is a safe directory name. */
+        ExtensionIdentifier: string;
         ExtensionKind: {
             /** @constant */
             type: "local";
@@ -1334,9 +1561,19 @@ declare interface components {
         };
         ExtensionPathVariables_for_CommonWorkspaceId: {
             eventId: components["schemas"]["EventId"];
-            extensionIdentifier: string;
+            extensionIdent: components["schemas"]["ExtensionIdentifier"];
             workspaceId: components["schemas"]["CommonWorkspaceId"];
         };
+        ExtensionSecretDTO: {
+            isSet: boolean;
+            /** @description Locale, like `en`, to label */
+            label: {
+                [key: string]: string;
+            };
+            name: components["schemas"]["SecretName"];
+            /** Format: date-time */
+            updatedAt?: string | null;
+        };
         /** @description Allows referencing an external resource for extended documentation. */
         ExternalDocumentation: {
             /**
@@ -2336,7 +2573,7 @@ declare interface components {
         /** Format: uint16 */
         InputIdx: InputIdx;
         InstallExtensionBody: {
-            identifier: string;
+            identifier: components["schemas"]["ExtensionIdentifier"];
             kind: components["schemas"]["ExtensionKind"];
         };
         InstalledExtensionDTO: {
@@ -2441,6 +2678,10 @@ declare interface components {
         } | {
             operationId: string;
         });
+        /** @description Links the entities a template was created from to its archive entries. */
+        LinkToTemplateMutation: {
+            wiring: components["schemas"]["Wiring"];
+        };
         LoadArchiveQuery: {
             /**
              * @description What to do with a root format contained in the archive.
@@ -2448,6 +2689,9 @@ declare interface components {
              */
             rootFormat: components["schemas"]["RootFormatImport"];
         };
+        LocalExtensionPath: {
+            extensionIdent: components["schemas"]["ExtensionIdentifier"];
+        };
         /**
          * Format: uint32
          * @description Identifies a type parameter within a type expression or node signature.
@@ -2640,6 +2884,10 @@ declare interface components {
             /** @constant */
             type: "unlink-from-template";
             data: components["schemas"]["UnlinkFromTemplateMutation"];
+        } | {
+            /** @constant */
+            type: "link-to-template";
+            data: components["schemas"]["LinkToTemplateMutation"];
         };
         LogEntrySmall: {
             description: string;
@@ -3788,7 +4036,6 @@ declare interface components {
             type: "unterminated-string";
         };
         PatchTableStateMutation: {
-            asOwner: components["schemas"]["TableOwnerDTO"];
             /** @description None resets the table state */
             state?: components["schemas"]["TableState"] | null;
             tableId: components["schemas"]["TableId"];
@@ -4456,6 +4703,17 @@ declare interface components {
             /** @description Additional external documentation for this schema. */
             externalDocs?: components["schemas"]["ExternalDocumentation"] | null;
         };
+        /** @description Only `[a-z0-9-]`, at least one character. */
+        SecretName: string;
+        SecretPath: {
+            extensionIdent: components["schemas"]["ExtensionIdentifier"];
+            name: components["schemas"]["SecretName"];
+        };
+        /** @description At most 16 KiB. Its [Debug] does not show the value. */
+        SecretValue: string;
+        SecretValueBody: {
+            value: components["schemas"]["SecretValue"];
+        };
         /**
          * @description Defines a security scheme that can be used by the operations.
          *      Supported schemes are HTTP authentication, an API key (either as a
@@ -4823,15 +5081,7 @@ declare interface components {
             nodeId: components["schemas"]["FormatNodeTestId"];
         };
         /** @enum {string} */
-        TableOwner: "none" | "nodes" | "user" | "race-office";
-        /**
-         * @description Same as [TableOwner] but without [TableOwner::None] and [TableOwner::Nodes] as users can't set these.
-         * @enum {string}
-         */
-        TableOwnerDTO: "user" | "race-office";
-        TableOwnerQuery: {
-            asOwner: components["schemas"]["TableOwnerDTO"];
-        };
+        TableOwner: "nodes" | "user";
         TablePathVariables_for_CommonWorkspaceId: {
             eventId: components["schemas"]["EventId"];
             tableId: components["schemas"]["TableId"];
@@ -5360,7 +5610,6 @@ declare interface components {
             variant: components["schemas"]["TableVariant"];
         };
         UpdateTableRowsLayerOneMutation: {
-            asOwner: components["schemas"]["TableOwnerDTO"];
             rows: components["schemas"]["Rows_for_Sorted"];
             tableId: components["schemas"]["TableId"];
         };
@@ -5419,7 +5668,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.
  */
-declare interface Conditional<T, R> {
+export declare interface Conditional<T, R> {
     tTest: TypeExpr<T, R>;
     tTestBound: TypeExpr<T, R>;
     tThen: TypeExpr<T, R>;
@@ -5430,21 +5679,67 @@ declare interface Conditional<T, R> {
     infer: LocalParamID[];
 }
 
+export declare function confirmDeleteItem(modalControls: ModalControls, itemName: string): Promise<boolean>;
+
 /**
  * Named type arguments of a [`TypeExpr::Constructor`](crate::TypeExpr::Constructor).
  *
  * Duplicate keys last-win in place: the original insertion position is kept.
  */
-declare type ConstructorParams<T, R = ParamRef> = Record<string, TypeExpr<T, R>>;
+export declare type ConstructorParams<T, R = ParamRef> = Record<string, TypeExpr<T, R>>;
+
+export declare interface ContextWasm {
+    values: Record<string, Value<Primitive>>;
+}
 
 export declare interface ContributionHandle<DTO> {
     beforeSubmit: (dto: DTO) => Promise<DTO | null>;
 }
 
+/** `createColumnHelper<AppTableFeatures, TData>()`, bound to `AppTable`'s feature registry. */
+export declare function createAppTableColumnHelper<TData extends RowData>(): ColumnHelper<    {
+columnSizingFeature: TableFeature;
+rowSelectionFeature: TableFeature;
+rowSortingFeature: TableFeature;
+sortedRowModel: (table: Table_2<any, any>) => () => RowModel<any, any>;
+rowPaginationFeature: TableFeature;
+paginatedRowModel: (table: Table_2<any, any>) => () => RowModel<any, any>;
+columnVisibilityFeature: TableFeature;
+}, TData>;
+
+export declare const DateTimeInput: FC<DateTimeInputProps>;
+
+export declare interface DateTimeInputProps {
+    value: Date | null;
+    onChange?: (value: Date | null) => void;
+    label?: string;
+    disabled?: boolean;
+    className?: string;
+    /**
+     * If true, empty input is accepted and mapped to null.
+     * Default: false
+     */
+    allowEmpty?: boolean;
+    readonly?: boolean;
+}
+
+export declare const DateTimeText: FC<DateTimeTextProps>;
+
+export declare interface DateTimeTextProps {
+    value: Date | number | string;
+    className?: string;
+}
+
 declare interface DetailedSupertypeDiagnostics<T> {
     layers: NoSupertypeLayer<T>[];
 }
 
+export declare interface DialogButton<T> {
+    value: T;
+    label: string;
+    theme?: 'primary' | 'default' | 'danger';
+}
+
 /** 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>;
@@ -5462,6 +5757,20 @@ export declare interface EventPath {
     eventId: EventId;
 }
 
+export declare type ExportableValue = string | number | boolean | null | undefined;
+
+export declare class ExpressionInContextWasm {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Runs the expression with the provided primitive values.
+     * @throws {ExpressionInContextError} if the expression is not valid or
+     * the returned value is non primitive and thus not serializable.
+     */
+    run(context: ContextWasm): Value<Primitive>;
+}
+
 export declare type ExtensionContribution<K extends keyof ExtensionContributions> = {
     /**
      * must be unique per type
@@ -5529,8 +5838,6 @@ export declare interface ExtensionSidebarContribution {
 
 export declare type ExtensionSidebarProps = EventPath;
 
-declare type FieldInput<Field> = Field extends OptionalQueryField<infer Value> ? Value | null : Field extends RepeatedQueryField<infer Value> ? readonly Value[] : never;
-
 declare interface FieldTypeWithDefault {
     fieldType: TypeExpr<Type>;
     /**
@@ -5539,15 +5846,19 @@ declare interface FieldTypeWithDefault {
     default: Value | null;
 }
 
-declare type FieldValue<Field> = Field extends OptionalQueryField<infer Value> ? Value | null : Field extends RepeatedQueryField<infer Value> ? Value[] : never;
+/**
+ * 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 type FormatGroupId = Brand<number, 'formatGroupId'>;
 
 declare type FormatId = Brand<number, 'formatId'>;
 
-declare type FormatInstanceId = Brand<number, 'formatInstanceId'>;
+export declare type FormatInstanceId = Brand<number, 'formatInstanceId'>;
 
-declare type FormatNodeId = Brand<string, 'formatNodeId'>;
+export declare type FormatNodeId = Brand<string, 'formatNodeId'>;
 
 declare type FormatNodeInstanceId = Brand<number, 'formatNodeInstanceId'>;
 
@@ -5555,12 +5866,14 @@ declare type FormatNodeTestId = Brand<string, 'formatNodeTestId'>;
 
 declare type FormatTestId = Brand<number, 'formatTestId'>;
 
-declare type FormContribution<Props, DTO> = FC<Props & {
+export declare type FormContribution<Props, DTO> = FC<Props & {
     formFieldRegistry: FormFieldRegistry;
     ref: Ref<ContributionHandle<DTO>>;
 }>;
 
-declare interface FormFieldMeta {
+export declare type FormFieldHookId = object;
+
+export declare interface FormFieldMeta {
     /**
      * true if setValue has been called at least once since the last reset
      */
@@ -5586,7 +5899,7 @@ declare interface FormFieldMeta {
     reset: () => void;
 }
 
-declare interface FormFieldProps<I, O = I> {
+export declare interface FormFieldProps<I, O = I> {
     /**
      * Used to check wether or not the mapped persisted value has changed
      * Default: `Object.is`
@@ -5601,9 +5914,9 @@ declare interface FormFieldProps<I, O = I> {
     map?: (value: I) => O;
 }
 
-declare interface FormFieldRegistry {
-    registerFormField: (hookId: HookId, formField: FormFieldMeta) => void;
-    unregisterFormField: (hookId: HookId) => void;
+export declare interface FormFieldRegistry {
+    registerFormField: (hookId: FormFieldHookId, formField: FormFieldMeta) => void;
+    unregisterFormField: (hookId: FormFieldHookId) => void;
     /**
      * `useFormField` bound to this registry. Follows the rules of hooks:
      * only call it at the top level of a component or custom hook.
@@ -5621,15 +5934,15 @@ declare interface FormFieldRegistry {
  * `const [value, setValue, field] = useFormField(...);`
  * `<FormField {...field}>...</FormField>`
  */
-declare type FormFieldState<T> = [value: T, setValue: (value: T | ((oldValue: T) => T)) => void, field: FormFieldMeta];
+export declare type FormFieldState<T> = [value: T, setValue: (value: T | ((oldValue: T) => T)) => void, field: FormFieldMeta];
 
 export declare type GameDAO = components['schemas']['GameDAO'];
 
-declare type GameDTO = components['schemas']['GameDTO'];
+export declare type GameDTO = components['schemas']['GameDTO'];
 
-declare type GameFormatDTO = components['schemas']['GameFormatDTO'];
+export declare type GameFormatDTO = components['schemas']['GameFormatDTO'];
 
-declare type GameFormatId = Brand<number, 'gameFormatId'>;
+export declare type GameFormatId = Brand<number, 'gameFormatId'>;
 
 export declare type GameFormatPageContribution = FormContribution<GameFormatPageProps & {
     gameFormat: GameFormatDTO;
@@ -5651,25 +5964,48 @@ export declare type GamePageProps = EventPath & {
 
 export declare const gamesWithTablesMappedByEventQO: (workspaceId: CommonWorkspaceId, eventId: EventId) => EngineQueryOptions<Map<GameId, GameWithTables>>;
 
-declare type GameWithTables = components['schemas']['GameWithTables'];
+export declare type GameWithTables = components['schemas']['GameWithTables'];
 
 export declare const getClassesByEventQO: (workspaceId: CommonWorkspaceId, eventId: EventId) => EngineQueryOptions<ClassResponse[]>;
 
+export declare const getCompetitorInTeamMappingAtQueryOptions: (workspaceId: CommonWorkspaceId, eventId: EventId, at: string) => EngineQueryOptions<CompetitorInTeamDAO[]>;
+
 /**
  * @deprecated useCompetitorsMapped instead
  */
 export declare const getCompetitorsQO: (workspaceId: CommonWorkspaceId, eventId: EventId, competitorTypeFilter?: CompetitorType) => EngineQueryOptions<CompetitorDAO[]>;
 
+export declare const getGameTableResolvedByGameQO: (workspaceId: CommonWorkspaceId, eventId: EventId, gameID: GameId, tableKind: "EntryList" | "ResultList") => EngineQueryOptions<TableSortedDTO>;
+
 /**
  * Location of a validation error in the graph.
  */
 declare type GraphLocation = { type: "Edge"; data: number } | { type: "InputPort"; data: { nodeIdx: number; inputIdx: number } };
 
-declare type HookId = object;
+export declare const H1: FC<H1Props>;
+
+export declare interface H1Props {
+    children?: ReactNode;
+    className?: string;
+}
+
+export declare const H2: FC<H2Props>;
+
+export declare interface H2Props {
+    children?: ReactNode;
+    className?: string;
+    noMargin?: boolean;
+}
+
+export declare function HR({ className }: HRProps): JSX.Element;
+
+export declare type HRProps = {
+    className?: string;
+};
 
 declare type InputIdx = Brand<number, 'inputIdx'>;
 
-declare enum InputLayout {
+export declare enum InputLayout {
     Normal = 0,
     /**
      * Narrow field for tight UI (node ports, toolbars). Overrides the browser's ~20ch input min-width.
@@ -5679,23 +6015,37 @@ declare enum InputLayout {
     Fill = 2
 }
 
+export declare const LoadingOverlay: FC<LoadingOverlayProps>;
+
+export declare type LoadingOverlayProps = {
+    /** When true, children are dimmed and a centered loading indicator is shown. */
+    active: boolean;
+    children: ReactNode;
+    /** Optional text shown below the spinner. */
+    loadingText?: ReactNode;
+    className?: string;
+};
+
 export declare type Locales = 'de' | 'en';
 
 /**
  * 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).
  */
-declare type LocalParamID = number;
+export declare type LocalParamID = number;
 
 declare type LogId = Brand<number, 'logId'>;
 
-declare type Merge<A, B> = {
+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;
 };
 
 export declare function Modal({ children, isOpen, onClose, closable, height, width, verticalPosition, horizontalPosition, lightbox, blockBackground, }: ModalProps): null;
 
-declare interface ModalConfig {
+/** Modal inner body: explicit width; shell uses `width: 'fit'` and shrink-wraps to this. */
+export declare const modalBodyNarrow = "p-6 w-[min(500px,calc(100vw - 2rem))] min-w-0 md:min-w-[320px]";
+
+export declare interface ModalConfig {
     id: string;
     content: ReactNode;
     closable?: boolean;
@@ -5708,12 +6058,12 @@ declare interface ModalConfig {
     onClose?: () => void;
 }
 
-declare interface ModalControls {
+export declare interface ModalControls {
     open: (content: ReactNode, options?: Omit<ModalConfig, 'id' | 'content'>) => string;
     close: (id: string) => void;
 }
 
-declare interface ModalProps {
+export declare interface ModalProps {
     children: ReactNode;
     isOpen: boolean;
     onClose: () => void;
@@ -5736,7 +6086,7 @@ declare interface ModalProps {
  * Function-like type for a node: generic parameters, inputs, outputs, and defaults.
  * Written in notation as `<T>(T) -> (T)` for the identity node.
  */
-declare interface NodeSignature<T, R = ParamRef> {
+export declare interface NodeSignature<T, R = ParamRef> {
     /**
      * Generic parameters with their bounds and defaults.
      */
@@ -5793,19 +6143,46 @@ declare interface NoSupertypeLayer<T> {
 
 declare type NoSupertypeLayerReason = "UnknownTypeParam" | "NodeSignatureInputsVarg" | "NodeSignatureInputs" | "NodeSignatureOutputs" | "NodeSignatureTags" | "NodeSignatureRequiredTags" | "PortTypesVarg" | "PortTypesArity" | "PortTypesPort" | "Index" | "ConstructorArity" | "ConstructorParam";
 
-declare type OperatorOf<T> = Extract<TypeOperators[keyof TypeOperators], [T, unknown]>[1];
+export declare function Note({ children, className }: NoteProps): JSX.Element;
 
-declare interface OptionalQueryField<T> {
+export declare interface NoteProps {
+    children: ReactNode;
+    className?: string;
+}
+
+/** `T` when `required` is true, otherwise `T | null`. */
+export declare type NullableUnlessRequired<T, Required extends boolean = false> = Required extends true ? T : T | null;
+
+export declare type OperatorOf<T> = Extract<TypeOperators[keyof TypeOperators], [T, unknown]>[1];
+
+declare interface Option_2<TVal> {
+    label: React_2.ReactNode;
+    value: TVal;
+    disabled?: boolean;
+}
+export { Option_2 as Option }
+
+export declare interface OptionalQueryField<T> {
     kind: 'optional';
     codec: QueryCodec<T>;
 }
 
 declare type OutputIdx = Brand<number, 'outputIdx'>;
 
+export declare const Page: FC<PageProps>;
+
+export declare type PageProps = {
+    children?: ReactNode;
+    /** Standard content padding (less on mobile). Default true. It is exposed as `--page-px` / `--page-py`. */
+    padding?: boolean;
+    className?: string;
+    style?: CSSProperties;
+};
+
 /**
  * References a local type parameter. This is context sensitive because parameters are scoped.
  */
-declare interface ParamRef {
+export declare interface ParamRef {
     paramId: LocalParamID;
     /**
      * If false, this reference will not be used to collect candidates for the parameter.
@@ -5814,19 +6191,37 @@ declare interface ParamRef {
     infer: boolean;
 }
 
-declare interface ParsedQuery<Values> {
+export declare interface ParsedQuery<Values> {
     values: Values;
     /** The original search with malformed known values removed and valid values normalized. */
     canonicalSearch: string;
     malformedKeys: string[];
 }
 
-declare type PathParams<Path extends string> = Path extends `${infer Base}/*` ? PathParams<Base> : Path extends `${infer _}/${infer Rest}` ? Merge<SegmentParam<_>, PathParams<Rest>> : SegmentParam<Path>;
+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}` ? {
+    [K in P]: number;
+} : S extends `$${infer P}` ? {
+    [K in P]: string;
+} : Record<never, never>;
+
+export declare type PersistedStateOptions = {
+    /**
+     * Where to persist the state.
+     * Default: StorageType.Session
+     */
+    storage: StorageType;
+    /**
+     * Useful if the version of the data ever changes
+     */
+    version?: number;
+};
 
 /**
  * A list of port types, optionally with a variadic type (`...T`).
  */
-declare interface PortTypes<T, R = ParamRef> {
+export declare interface PortTypes<T, R = ParamRef> {
     ports: TypeExpr<T, R>[];
     varg: TypeExpr<T, R> | null;
 }
@@ -5834,68 +6229,36 @@ declare interface PortTypes<T, R = ParamRef> {
 /**
  * Crate local version of [std::convert::Infallible]
  */
-declare type Primitive = never;
-
-declare type Props = {
-    type?: AppButtonType;
-    onClick?: () => void;
-    disabled?: boolean;
-    /** Disabled while read-only (see `useIsReadonly`). */
-    mutates?: boolean;
-    children?: ReactNode;
-    submit?: boolean;
-    className?: string;
-    loading?: boolean;
-    value?: string;
-    ref?: RefObject<HTMLButtonElement | null>;
-    /** Makes the button a link to this route, so it can also be opened in a new tab. `onClick` runs before routing. */
-    href?: string;
-};
+export declare type Primitive = never;
 
-declare type Props_2 = {
-    label?: string;
-    description?: string;
-    value?: string;
-    onChange?: ChangeEventHandler<HTMLInputElement>;
-    onBlur?: FocusEventHandler<HTMLInputElement>;
-    onFocus?: FocusEventHandler<HTMLInputElement>;
-    onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
-    type?: HTMLInputTypeAttribute;
-    placeholder?: string;
-    required?: boolean;
-    maxLength?: number;
-    disabled?: boolean;
-    className?: string;
-    tabIndex?: number;
-    readonly?: boolean;
-    layout?: InputLayout;
-    inputRef?: React.RefObject<HTMLInputElement | null>;
-    endAdornment?: ReactNode;
-    autoFocus?: boolean;
-};
+export declare function primValueToTypeExpr(value: Value<Primitive>): TypeExpr<Type, ParamRef>;
 
-declare interface QueryCodec<T> {
+export declare interface QueryCodec<T> {
     parse(value: string): T | null;
     serialize(value: T): string;
 }
 
-declare type QueryField = OptionalQueryField<unknown> | RepeatedQueryField<unknown>;
+export declare type QueryField = OptionalQueryField<unknown> | RepeatedQueryField<unknown>;
+
+export declare type QueryFieldInput<Field> = Field extends OptionalQueryField<infer Value> ? Value | null : Field extends RepeatedQueryField<infer Value> ? readonly Value[] : never;
+
+export declare type QueryFields = Record<string, QueryField>;
 
-declare type QueryFields = Record<string, QueryField>;
+export declare type QueryFieldValue<Field> = Field extends OptionalQueryField<infer Value> ? Value | null : Field extends RepeatedQueryField<infer Value> ? Value[] : never;
 
-declare type QueryInput<Schema extends AnyQuerySchema> = Schema extends QuerySchema<infer Fields> ? {
-    [Key in keyof Fields]?: FieldInput<Fields[Key]>;
+export declare type QueryInput<Schema extends AnyQuerySchema> = Schema extends QuerySchema<infer Fields> ? {
+    [Key in keyof Fields]?: QueryFieldInput<Fields[Key]>;
 } : never;
 
-declare interface QuerySchema<Fields extends QueryFields> {
+export declare interface QuerySchema<Fields extends QueryFields> {
     readonly fields: Fields;
     parse(search: string): ParsedQuery<{
-        [Key in keyof Fields]: FieldValue<Fields[Key]>;
+        [Key in keyof Fields]: QueryFieldValue<Fields[Key]>;
     }>;
     serialize(input?: {
-        [Key in keyof Fields]?: FieldInput<Fields[Key]>;
+        [Key in keyof Fields]?: QueryFieldInput<Fields[Key]>;
     }): string;
-    set<Key extends keyof Fields>(search: string, key: Key, value: FieldValue<Fields[Key]>): string;
+    set<Key extends keyof Fields>(search: string, key: Key, value: QueryFieldValue<Fields[Key]>): string;
 }
 
 /**
@@ -5909,14 +6272,42 @@ declare interface RecordTypeWithDefaults {
     properties: Record<string, FieldTypeWithDefault>;
 }
 
-declare type RecordValue<T = Primitive> = Record<string, Value<T>>;
+export declare type RecordValue<T = Primitive> = Record<string, Value<T>>;
 
-declare interface RepeatedQueryField<T> {
+export declare function refocusWhenEnabled(input: HTMLInputElement | null | undefined, attempt?: number): void;
+
+export declare interface RepeatedQueryField<T> {
     kind: 'repeated';
     codec: QueryCodec<T>;
 }
 
-declare interface RouterContextType {
+export declare function ResizablePanel({ value, onChange, edge, min, max, hideWhenBelowMin, onClose, children, className, contentClassName, }: ResizablePanelProps): JSX.Element;
+
+export declare interface ResizablePanelProps {
+    /** Current size value (width for left/right, height for top/bottom) */
+    value: number;
+    /** Called when size changes during drag */
+    onChange: (value: number) => void;
+    /** Which edge has the drag handle */
+    edge: ResizeEdge;
+    /** Minimum size (optional) */
+    min?: number;
+    /** Maximum size (optional) */
+    max?: number;
+    /** When true, collapses to 0 when dragged below min and fires onClose on mouse release */
+    hideWhenBelowMin?: boolean;
+    /** Called when hideWhenBelowMin is true and user releases mouse below minimum */
+    onClose?: () => void;
+    children: React_2.ReactNode;
+    /** Additional class names for the container */
+    className?: string;
+    /** Additional class names for the content wrapper */
+    contentClassName?: string;
+}
+
+export declare type ResizeEdge = 'left' | 'right' | 'top' | 'bottom';
+
+export declare interface RouterContextType {
     /** The pathname used for route matching and persistence keys. */
     path: string;
     /** The complete reactive browser location. */
@@ -5934,7 +6325,7 @@ declare interface RouterContextType {
     unregister: (route: string) => void;
 }
 
-declare interface RouterLocation {
+export declare interface RouterLocation {
     pathname: string;
     search: string;
     hash: string;
@@ -5952,6 +6343,18 @@ declare interface Row {
     columns: RecordValue;
 }
 
+export declare interface RowAction<T> {
+    id: string;
+    type?: AppButtonType;
+    label: ReactNode | string;
+    icon?: ReactNode;
+    triggerSingle: (row: T) => void | Promise<void>;
+    triggerMultiple?: (rows: T[]) => void | Promise<void>;
+    supportsRow?: (row: T) => boolean;
+    /** Stays available in read-only workspaces. */
+    readOnlySafe?: boolean;
+}
+
 declare type RowMutationId = Brand<number, 'rowMutationId'>;
 
 declare interface Rows<SortingState> {
@@ -5962,14 +6365,41 @@ declare interface Rows<SortingState> {
     rows: Row[];
 }
 
-declare type SegmentParam<S extends string> = S extends `:${infer P}` ? {
-    [K in P]: number;
-} : S extends `$${infer P}` ? {
-    [K in P]: string;
-} : Record<never, never>;
+export declare enum RowState {
+    /** The item is persisted in the backend as displayed and is managed by nodes. */
+    Unchanged = 0,
+    /** The item is persisted but updated in the ui. */
+    Updated = 1,
+    /** The item is persisted but deleted in the ui. */
+    Deleted = 2,
+    /** The item is not yet persisted. */
+    Added = 3
+}
+
+export declare function SearchInput({ value, onChange, placeholder, className }: SearchInputProps): JSX.Element;
+
+export declare type SearchInputProps = {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    className?: string;
+};
 
 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: number } | { type: "closure" };
 
+/**
+ * A keyboard shortcut as the keys to press together, e.g. `['Mod', 'Shift', 'Z']`. `Mod` is Ctrl, or
+ * Cmd on Apple platforms, matching handlers that read `ctrlKey || metaKey`. Pointer gestures
+ * (`Click`, `Drag`, `Scroll`) are written like keys so they read the same way: "Shift+Click".
+ */
+export declare type Shortcut = readonly string[];
+
+/**
+ * Shows a dialog that can be dismissed (ESC, click outside, or X button)
+ * Returns the selected value or null if dismissed
+ */
+export declare function showDialog<T>(modal: ModalControls, buttons: DialogButton<T>[], content: ReactNode): Promise<T | null>;
+
 declare type Sorted = Brand<'sorted', 'sorted'>;
 
 /**
@@ -5988,22 +6418,91 @@ declare interface StateMetadata {
     state: TableState;
 }
 
+export declare enum StorageType {
+    Session = 0,
+    Local = 1
+}
+
 /**
  * Combines rows with table attributes and state
  */
 declare type Table<SortingState, M = NoMetadata> = { rows: Rows<SortingState> } & M;
 
-declare type TableId = Brand<number, 'tableId'>;
+export declare type TableId = Brand<number, 'tableId'>;
 
 declare type TableLineageId = Brand<number, 'tableLineageId'>;
 
-declare type TableSorting = "unsorted" | "sorted";
+export declare interface TableProps<TData extends RowData> {
+    data: TData[];
+    columns: ColumnDef<AppTableFeatures, TData, unknown>[];
+    actions?: RowAction<TData>[];
+    allowSelect?: boolean;
+    getRowId?: (row: TData, index: number) => string;
+    getRowState?: (row: TData) => RowState;
+    rowClicked?: (row: TData) => void;
+    /**
+     * Route a row leads to. Clicking the row routes there (after `rowClicked`); a middle or Ctrl click
+     * opens it in a new tab.
+     */
+    rowHref?: (row: TData) => string;
+    /**
+     * Default: true
+     */
+    enableSorting?: boolean;
+    /** Should be one of pageSizes */
+    initialPageSize?: number;
+    initialSorting?: SortingState;
+    pageSizes?: number[];
+    /**
+     * ~Composer:
+     * When true (default), TanStack Table resets the page index when `data` changes.
+     * Set to false if edits replace the `data` array often but you want to keep the current page.
+     */
+    autoResetPageIndex?: boolean;
+    /** Text to be displayed when there is no data */
+    emptyTableText?: ReactNode;
+    /**
+     * When provided, shows a "Columns" toggle button above the table and persists column
+     * visibility to localStorage under this key. Columns with `enableHiding: false` are excluded.
+     */
+    columnVisibilityStorageKey?: string;
+}
+
+export declare type TableSortedDTO = components['schemas']['Table_for_Sorted_and_StateMetadata'];
+
+export declare type TableSorting = "unsorted" | "sorted";
 
 declare type TableState = number;
 
+export declare type TimeDelta = components['schemas']['TimeDeltaSchema'];
+
+export declare const TimeDeltaInput: FC<TimeDeltaInputProps>;
+
+export declare interface TimeDeltaInputProps {
+    value: TimeDelta;
+    onChange?: (value: TimeDelta) => void;
+    label?: string;
+    className?: string;
+    readonly?: boolean;
+}
+
 export { toast }
 
-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" };
+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" };
+
+/**
+ * Can be parsed from string with the following syntax:
+ *
+ * `TypeContext ::= <Record> "->" <TypeExpr>`
+ *
+ * # Examples:
+ * - `{a: Integer} -> Float`
+ * - `{} -> Any`
+ */
+export declare interface TypeContext {
+    variables: Record<string, TypeExpr<Type, ParamRef>>;
+    returnType: TypeExpr<Type, ParamRef>;
+}
 
 /**
  * Type expression—the core type representation in nodety.
@@ -6014,18 +6513,18 @@ declare type Type = { type: "integer"; data: { min: number | null; max: number |
  * [`PartialEq`], [`Eq`] and [`Hash`] are structural: `A | B` is not equal to `B | A`.
  * [`Eq`] and [`Hash`] are available when `T: Eq + Hash`.
  */
-declare type TypeExpr<T, R = ParamRef> = { type: "Type"; data: T } | { type: "Constructor"; data: { inner: T; parameters: ConstructorParams<T, R> } } | { type: "Operation"; data: { a: TypeExpr<T, R>; operator: OperatorOf<T>; b: TypeExpr<T, R> } } | { type: "NodeSignature"; data: NodeSignature<T, R> } | { type: "PortTypes"; data: PortTypes<T, R> } | { type: "Union"; data: [TypeExpr<T, R>, TypeExpr<T, R>] } | { type: "KeyOf"; data: TypeExpr<T, R> } | { type: "Index"; data: { expr: TypeExpr<T, R>; index: TypeExpr<T, R> } } | { type: "Intersection"; data: [TypeExpr<T, R>, TypeExpr<T, R>] } | { type: "Conditional"; data: Conditional<T, R> } | { type: "Any" } | { type: "Never" } | { type: "Ref"; data: R };
+export declare type TypeExpr<T, R = ParamRef> = { type: "Type"; data: T } | { type: "Constructor"; data: { inner: T; parameters: ConstructorParams<T, R> } } | { type: "Operation"; data: { a: TypeExpr<T, R>; operator: OperatorOf<T>; b: TypeExpr<T, R> } } | { type: "NodeSignature"; data: NodeSignature<T, R> } | { type: "PortTypes"; data: PortTypes<T, R> } | { type: "Union"; data: [TypeExpr<T, R>, TypeExpr<T, R>] } | { type: "KeyOf"; data: TypeExpr<T, R> } | { type: "Index"; data: { expr: TypeExpr<T, R>; index: TypeExpr<T, R> } } | { type: "Intersection"; data: [TypeExpr<T, R>, TypeExpr<T, R>] } | { type: "Conditional"; data: Conditional<T, R> } | { type: "Any" } | { type: "Never" } | { type: "Ref"; data: R };
 
 declare type TypeExprValidationError = { type: "UnknownVar"; var: LocalParamID } | { type: "CyclicReference" };
 
-declare interface TypeOperators { graphite: [Type, ArithmeticOperator] }
+export declare interface TypeOperators { graphite: [Type, ArithmeticOperator] }
 
-declare interface TypeOperators {}
+export declare interface TypeOperators {}
 
 /**
  * A generic type parameter with optional bound and default.
  */
-declare interface TypeParameter<T, R = ParamRef> {
+export declare interface TypeParameter<T, R = ParamRef> {
     /**
      * Upper bound (e.g. `T extends Comparable`).
      */
@@ -6041,7 +6540,7 @@ declare interface TypeParameter<T, R = ParamRef> {
  *
  * Exists so that it can implement traits like [std::str::FromStr]
  */
-declare type TypeParameters<T, R = ParamRef> = Record<LocalParamID, TypeParameter<T, R>>;
+export declare type TypeParameters<T, R = ParamRef> = Record<LocalParamID, TypeParameter<T, R>>;
 
 declare type Unsorted = Brand<'unsorted', 'unsorted'>;
 
@@ -6054,11 +6553,37 @@ declare type Unsorted_2 = null;
 /** The engine's active locale. Extensions ship their own dictionaries and select them by it. */
 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(): (path: string, init?: RequestInit) => Promise<Response>;
+
+/** The identifier the calling extension is installed under, e.g. the key of its `extensionData`. */
+export declare function useExtensionIdentifier(): string;
+
+export declare function useMediaQuery(query: string): boolean;
+
 export declare function useModal(): ModalControls;
 
+/**
+ * @todo Add a parameter to save stuff in localstorage or even better, per user
+ *
+ * Wrapper for useState with persistence in sessionstorage.
+ * Only serializes and writes to sessionstorage on window.beforeunload
+ *
+ * @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.
+ * @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];
+
 /** Hook to use the router context. Must be called within a <Router> provider. */
 export declare function useRouter(): RouterContextType;
 
+/**
+ * Validates the expression and returns a `ExpressionInContextWasm` if the expression is valid.
+ * @throws {ValidateExpressionError} if the expression is not valid.
+ */
+export declare function validateExpression(expression: string, context: TypeContext): ExpressionInContextWasm;
+
 /**
  * A validation error with its location and kind.
  */
@@ -6069,7 +6594,19 @@ 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> };
 
-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 };
+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 };
+
+/**
+ * Turns a Value into an ExportableValue
+ */
+export declare function valueIntoExportable(value: Value): ExportableValue;
+
+export declare function Warning({ children, className }: WarningProps): JSX.Element;
+
+export declare interface WarningProps {
+    children: ReactNode;
+    className?: string;
+}
 
 /**
  * Same as GameDTO but with gameFormatId optional
@@ -6078,8 +6615,8 @@ export declare type WorkingGameDTO = Omit<GameDTO, 'gameFormatId'> & {
     gameFormatId: GameFormatId | null;
 };
 
-declare type WorkspaceRootId = Brand<number, 'workspaceRootId'>;
+export declare type WorkspaceRootId = Brand<number, 'workspaceRootId'>;
 
-declare type WorkspaceSelfHostedId = Brand<number, 'workspaceSelfHostedId'>;
+export declare type WorkspaceSelfHostedId = Brand<number, 'workspaceSelfHostedId'>;
 
 export { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphite-sports/sdk",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "repository": "github:Graphite-sports/starter-extension",
   "homepage": "https://github.com/Graphite-sports/starter-extension",
@@ -10,7 +10,10 @@
     "index.d.ts"
   ],
   "peerDependencies": {
+    "@headlessui/react": "^2.2.7",
     "@tanstack/react-query": "^5.90.7",
+    "@tanstack/react-table": "^9.2.4",
+    "@tanstack/table-core": "^9.2.4",
     "react": "^19.1.1",
     "react-hot-toast": "^2.6.0"
   }