@graphite-sports/sdk 0.1.1 → 0.2.0

package/index.d.ts

@@ -1,13 +1,29 @@
 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';
 
@@ -33,6 +49,31 @@ export declare type AppButtonProps = {
 
 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 }: AppInputProps & {
         ref?: React.RefObject<HTMLInputElement | null>;
@@ -63,11 +104,118 @@ export declare type AppInputProps = {
     autoFocus?: boolean;
 };
 
-declare type ArithmeticOperator = "add" | "subtract";
+export declare function AppListbox<TVal>({ options, value, onChange, label, description, disabled, placeholder, className, direction, readonly: readonlyProp, required, }: AppListboxProps<TVal>): JSX.Element;
 
-declare type ArrayValue<T = Primitive> = Value<T>[];
+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;
+};
 
-declare type BIB = Brand<number, 'bib'>;
+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;
+
+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, 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
@@ -79,6 +227,9 @@ 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;
@@ -191,6 +342,41 @@ export declare type CompetitorDAO = components['schemas']['CompetitorDAO'];
 
 export declare type CompetitorId = Brand<number, 'competitorId'>;
 
+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 {
@@ -1362,7 +1548,7 @@ declare interface components {
             kind: components["schemas"]["ExtensionKind"];
         };
         /** @enum {string} */
-        ExtensionError: "local-extension-not-found" | "failed-to-resolve-extension" | "failed-to-start" | "invalid-identifier";
+        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: {
@@ -3850,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"];
@@ -4896,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"];
@@ -5433,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"];
         };
@@ -5492,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>;
@@ -5503,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>;
@@ -5535,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
@@ -5610,6 +5846,12 @@ declare interface FieldTypeWithDefault {
     default: Value | null;
 }
 
+/**
+ * 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'>;
@@ -5726,16 +5968,41 @@ 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 } };
 
+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'>;
 
 export declare enum InputLayout {
@@ -5748,13 +6015,24 @@ export 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'>;
 
@@ -5764,6 +6042,9 @@ export declare type MergePathParams<A, B> = {
 
 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. */
+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;
@@ -5805,7 +6086,7 @@ export 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.
      */
@@ -5862,7 +6143,24 @@ 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;
+
+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';
@@ -5871,10 +6169,20 @@ export declare interface OptionalQueryField<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.
@@ -5898,10 +6206,22 @@ export declare type PathSegmentParam<S extends string> = 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;
 }
@@ -5909,7 +6229,9 @@ declare interface PortTypes<T, R = ParamRef> {
 /**
  * Crate local version of [std::convert::Infallible]
  */
-declare type Primitive = never;
+export declare type Primitive = never;
+
+export declare function primValueToTypeExpr(value: Value<Primitive>): TypeExpr<Type, ParamRef>;
 
 export declare interface QueryCodec<T> {
     parse(value: string): T | null;
@@ -5950,13 +6272,41 @@ 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>>;
+
+export declare function refocusWhenEnabled(input: HTMLInputElement | null | undefined, attempt?: number): void;
 
 export declare interface RepeatedQueryField<T> {
     kind: 'repeated';
     codec: QueryCodec<T>;
 }
 
+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;
@@ -5993,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> {
@@ -6003,8 +6365,41 @@ declare interface Rows<SortingState> {
     rows: Row[];
 }
 
+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'>;
 
 /**
@@ -6023,6 +6418,11 @@ declare interface StateMetadata {
     state: TableState;
 }
 
+export declare enum StorageType {
+    Session = 0,
+    Local = 1
+}
+
 /**
  * Combines rows with table attributes and state
  */
@@ -6032,13 +6432,77 @@ 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.
@@ -6049,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`).
      */
@@ -6076,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'>;
 
@@ -6089,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.
  */
@@ -6104,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphite-sports/sdk",
-  "version": "0.1.1",
+  "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"
   }