@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/grid/core/pro-gate/grid-pro-gate.d.ts

@@ -0,0 +1,51 @@
+import type { GridLicense, GridLicenseAttributes, GridLicenseOptions, GridLicenseState } from '../license/grid-license';
+import { GridFeatureError } from '../license/grid-feature';
+import type { GridFeatureSteps } from '../license/grid-feature';
+export interface GridProGateHooks {
+    changed(display: boolean): void;
+    safePoint(): boolean;
+    activated(feature: string): void;
+    liveChanged?(): void;
+}
+export type GridProRefusalAction = 'inert' | 'refused' | 'missing';
+export declare class GridProGate {
+    private readonly host;
+    private readonly hooks;
+    private readonly options;
+    private binding;
+    private readonly display;
+    private readonly noted;
+    private readonly liveOnly;
+    private flushQueued;
+    private deferred;
+    constructor(host: Element, hooks: GridProGateHooks, options?: GridLicenseOptions);
+    license(): GridLicense;
+    displayRevision(): number;
+    displayState(feature: string): GridLicenseState;
+    allowed(feature: string, member: string): boolean;
+    workAllowed(feature: string, member: string): boolean;
+    newWorkAllowed(feature: string, member: string): boolean;
+    moduleAvailable(feature: string, member: string, chunkId: string, available: boolean): boolean;
+    lost(feature: string): boolean;
+    admitAny(features: readonly string[], member: string): Promise<void>;
+    liveDeclaration(feature: string, member: string): GridLicenseState;
+    admitChunk(chunkId: string, features: readonly string[]): Promise<void> | undefined;
+    method<M = undefined, C = undefined, R = C>(name: string, isLoaded: (chunk: string) => boolean, steps: GridFeatureSteps<M, C, R>): Promise<R>;
+    moduleFailure(error: unknown, feature: string, method: string): unknown;
+    admit(feature: string, member: string): Promise<void>;
+    awaiting(features: readonly string[]): boolean;
+    settle(features: readonly string[]): Promise<void>;
+    refuseRequest(features: readonly string[], member: string): GridFeatureError[];
+    frozen(feature: string): boolean;
+    entitled(feature: string): boolean;
+    refusalError(feature: string, member: string): GridFeatureError;
+    private afterRefusal;
+    attributes(): GridLicenseAttributes;
+    afterRender(): void;
+    rebind(): void;
+    detach(): void;
+    flushRefusals(): void;
+    private note;
+    private onLicenseChange;
+    private commit;
+}

package/dist/types/components/grid/core/pro-gate/grid-state-requirements.d.ts

@@ -0,0 +1,21 @@
+import type { SyGridState, SyGridStateEnvelopeIssue } from '../state/contracts';
+import type { GridStateApplyPlan } from '../state/grid-state';
+import type { FilterSliceApplyResult } from '../state/slices/filter';
+export interface GridStateProRequirement {
+    readonly feature: string;
+    readonly path: string;
+    readonly detail: string;
+}
+export interface GridStateRefusedFeature {
+    readonly feature: string;
+    readonly state: string;
+    readonly code: string;
+}
+export declare function scanGridStateProRequirements(plan: GridStateApplyPlan, state?: SyGridState | null): GridStateProRequirement[];
+export declare function scanFilterProRequirements(filter: Pick<FilterSliceApplyResult, 'builtIn' | 'conditionTree'>, root: string): GridStateProRequirement[];
+export declare function gridStateRequirementFeatures(requirements: readonly GridStateProRequirement[]): string[];
+export declare function gridStateLicenseIssues(requirements: readonly GridStateProRequirement[], refused: readonly GridStateRefusedFeature[]): SyGridStateEnvelopeIssue[];
+export declare const GRID_PRO_FILTER_FEATURES: ReadonlySet<string>;
+export declare function gridProFilterRequirements(requirements: readonly GridStateProRequirement[]): GridStateProRequirement[];
+export declare function gridStateModuleIssues(requirements: readonly GridStateProRequirement[], cause: 'module-missing' | 'load-failed', chunkId: string): SyGridStateEnvelopeIssue[];
+export declare function refusedGridStatePlan(plan: GridStateApplyPlan, licenseIssues: readonly SyGridStateEnvelopeIssue[]): GridStateApplyPlan;

package/dist/types/components/grid/core/pro-panels/column-menu.d.ts

@@ -0,0 +1,38 @@
+import type { ColumnDef } from '../types';
+import type { ColumnPinSide } from '../column/column-pin';
+export interface GridColumnMenuItem {
+    readonly id: string;
+    readonly label: string;
+    readonly disabled?: boolean;
+    readonly onSelect: () => void | Promise<void>;
+}
+export interface GridColumnMenuContext {
+    readonly colId: string;
+    readonly column: Readonly<ColumnDef>;
+}
+export interface GridColumnMenuHost {
+    readonly host: HTMLElement;
+    readonly columnMenu: boolean;
+    readonly columnMenuItems?: (context: GridColumnMenuContext) => readonly GridColumnMenuItem[];
+    readonly effectiveLoading: boolean;
+    readonly columnHidden: ReadonlySet<string>;
+    readonly activeSortModel: readonly {
+        field: string;
+        direction: 'asc' | 'desc';
+    }[];
+    proUiChunkTick: number;
+    proNewWorkAllowed(feature: string, member: string): boolean;
+    resolvedColumnDefs(): ColumnDef[];
+    columnHidingActive(): boolean;
+    setSortModel(model: {
+        field: string;
+        direction: 'asc' | 'desc';
+    }[]): Promise<unknown>;
+    setColumnPinned(field: string, side: ColumnPinSide | null): Promise<void>;
+    hideColumn(field: string): Promise<void>;
+    showColumn(field: string): Promise<void>;
+    toggleFilterDropdown(col: ColumnDef, anchor: HTMLElement | null): void;
+}
+export declare function closeColumnMenu(grid: GridColumnMenuHost, restoreFocus?: boolean): void;
+export declare function renderColumnMenuButton(grid: GridColumnMenuHost, col: ColumnDef): any;
+export declare function renderColumnMenu(grid: GridColumnMenuHost): any;

package/dist/types/components/grid/core/rbac/cell-access.d.ts

@@ -0,0 +1,12 @@
+export interface RbacCellReadParams {
+    readonly rowIndex: number;
+    readonly field: string;
+    readonly colId: string;
+    readonly data: Record<string, unknown> | null;
+    readonly value: unknown;
+}
+export type CanReadCellFn = (params: RbacCellReadParams) => boolean;
+export declare function resolveCellReadable(params: RbacCellReadParams, policy: CanReadCellFn | null | undefined, onError?: (err: unknown) => void): boolean;
+export declare function maskCellValue<T>(value: T, readable: boolean, mask: string): T | string;
+export type CanEditCellFn = (params: RbacCellReadParams) => boolean;
+export declare function resolveCellEditable(params: RbacCellReadParams, policy: CanEditCellFn | null | undefined, onError?: (err: unknown) => void): boolean;

package/dist/types/components/grid/core/row-drag/drag-safety.d.ts

@@ -0,0 +1,268 @@
+import type { RowDragEndReason } from './unmanaged-drag.ts';
+export declare const POINTER_TYPES: readonly [
+    "mouse",
+    "pen",
+    "touch"
+];
+export type DragPointerType = (typeof POINTER_TYPES)[number];
+export declare const GESTURE_PHASES: readonly [
+    "idle",
+    "pending",
+    "armed",
+    "yielded"
+];
+export type GesturePhase = (typeof GESTURE_PHASES)[number];
+export declare const GESTURE_YIELD_REASONS: readonly [
+    "scroll-intent",
+    "hold-too-short",
+    "multi-touch",
+    "pointer-changed",
+    "cancelled"
+];
+export type GestureYieldReason = (typeof GESTURE_YIELD_REASONS)[number];
+export interface DragThresholdConfig {
+    readonly mouse: number;
+    readonly pen: number;
+    readonly touch: number;
+    readonly touchHoldTicks: number;
+    readonly scrollAxisRatio: number;
+}
+export declare const DEFAULT_DRAG_THRESHOLDS: DragThresholdConfig;
+export interface PointerSample {
+    readonly pointerId: number;
+    readonly pointerType: DragPointerType;
+    readonly x: number;
+    readonly y: number;
+    readonly tick: number;
+    readonly contacts?: number;
+}
+export interface GestureState {
+    readonly phase: GesturePhase;
+    readonly pointerId: number | null;
+    readonly pointerType: DragPointerType | null;
+    readonly originX: number;
+    readonly originY: number;
+    readonly originTick: number;
+    readonly heldTicks: number;
+    readonly travelled: number;
+    readonly yieldReason: GestureYieldReason | null;
+}
+export declare const IDLE_GESTURE: GestureState;
+export declare function beginGesture(sample: PointerSample): GestureState;
+export declare function advanceGesture(state: GestureState, sample: PointerSample, config?: DragThresholdConfig, scrollAxis?: 'vertical' | 'horizontal' | 'none'): GestureState;
+export declare function cancelGesture(state: GestureState): GestureState;
+export type WritingDirection = 'ltr' | 'rtl';
+export declare function toInlineDelta(dx: number, direction: WritingDirection): number;
+export declare const INDENT_INTENTS: readonly [
+    "indent",
+    "outdent",
+    "none"
+];
+export type IndentIntent = (typeof INDENT_INTENTS)[number];
+export declare function resolveIndentIntent(key: 'left' | 'right', direction: WritingDirection): IndentIntent;
+export interface ScrollBox {
+    readonly id: string;
+    readonly scrollLeft: number;
+    readonly scrollTop: number;
+    readonly scrollWidth: number;
+    readonly scrollHeight: number;
+    readonly clientWidth: number;
+    readonly clientHeight: number;
+    readonly left: number;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly direction?: WritingDirection;
+}
+export interface AutoScrollConfig {
+    readonly edge: number;
+    readonly maxSpeed: number;
+}
+export declare const DEFAULT_AUTO_SCROLL: AutoScrollConfig;
+export interface AutoScrollVelocity {
+    readonly dx: number;
+    readonly dy: number;
+}
+export declare const NO_AUTO_SCROLL: AutoScrollVelocity;
+export declare function autoScrollVelocity(box: ScrollBox, x: number, y: number, config?: AutoScrollConfig): AutoScrollVelocity;
+export declare function canScroll(box: ScrollBox, dx: number, dy: number): boolean;
+export interface AutoScrollPlan {
+    readonly boxId: string | null;
+    readonly velocity: AutoScrollVelocity;
+    readonly fellThrough: readonly string[];
+    readonly exhausted: boolean;
+}
+export declare const NO_AUTO_SCROLL_PLAN: AutoScrollPlan;
+export interface NestedAutoScrollOptions {
+    readonly inheritIntent?: boolean;
+}
+export declare function resolveAutoScroll(chain: readonly ScrollBox[], x: number, y: number, config?: AutoScrollConfig, options?: NestedAutoScrollOptions): AutoScrollPlan;
+export declare const KEYBOARD_REORDER_COMMANDS: readonly [
+    "up",
+    "down",
+    "top",
+    "bottom",
+    "page-up",
+    "page-down"
+];
+export type KeyboardReorderCommand = (typeof KEYBOARD_REORDER_COMMANDS)[number];
+export declare const KEYBOARD_REORDER_REFUSALS: readonly [
+    "no-grab",
+    "already-grabbed",
+    "index-out-of-range",
+    "unknown-command",
+    "at-boundary"
+];
+export type KeyboardReorderRefusal = (typeof KEYBOARD_REORDER_REFUSALS)[number];
+export interface KeyboardReorderState<TData> {
+    readonly grabbed: boolean;
+    readonly originIndex: number;
+    readonly currentIndex: number;
+    readonly rows: readonly TData[];
+    readonly rowKey: string | null;
+}
+export type KeyboardReorderResult<TData> = {
+    readonly outcome: 'moved';
+    readonly fromIndex: number;
+    readonly toIndex: number;
+    readonly rows: readonly TData[];
+    readonly announcement: DragAnnouncement;
+} | {
+    readonly outcome: 'refused';
+    readonly reason: KeyboardReorderRefusal;
+    readonly detail: string;
+    readonly announcement: DragAnnouncement | null;
+};
+export type KeyboardDropResult<TData> = {
+    readonly outcome: 'dropped';
+    readonly rows: readonly TData[];
+    readonly fromIndex: number;
+    readonly toIndex: number;
+    readonly announcement: DragAnnouncement;
+} | {
+    readonly outcome: 'refused';
+    readonly reason: KeyboardReorderRefusal;
+    readonly detail: string;
+    readonly announcement: null;
+};
+export interface KeyboardReorderController<TData> {
+    grab(index: number): KeyboardReorderResult<TData>;
+    move(command: KeyboardReorderCommand): KeyboardReorderResult<TData>;
+    drop(): KeyboardDropResult<TData>;
+    cancel(): KeyboardDropResult<TData>;
+    state(): KeyboardReorderState<TData>;
+    rows(): readonly TData[];
+    announcements(): readonly DragAnnouncement[];
+}
+export interface KeyboardReorderConfig<TData> {
+    readonly rows: readonly TData[];
+    readonly getRowKey: (row: TData, index: number) => string;
+    readonly getRowLabel?: (row: TData, index: number) => string;
+    readonly pageSize?: number;
+}
+export declare const DEFAULT_KEYBOARD_PAGE_SIZE = 10;
+export declare function createKeyboardReorder<TData>(config: KeyboardReorderConfig<TData>): KeyboardReorderController<TData>;
+export declare const ANNOUNCEMENT_KINDS: readonly [
+    "grab",
+    "move",
+    "drop",
+    "cancel",
+    "boundary",
+    "orphaned"
+];
+export type AnnouncementKind = (typeof ANNOUNCEMENT_KINDS)[number];
+export declare const ANNOUNCEMENT_POLITENESS: readonly [
+    "polite",
+    "assertive"
+];
+export type AnnouncementPoliteness = (typeof ANNOUNCEMENT_POLITENESS)[number];
+export interface DragAnnouncement {
+    readonly kind: AnnouncementKind;
+    readonly politeness: AnnouncementPoliteness;
+    readonly text: string;
+}
+export interface AnnouncementInput {
+    readonly kind: AnnouncementKind;
+    readonly label: string;
+    readonly position: number;
+    readonly total: number;
+    readonly from?: number;
+    readonly atTop?: boolean;
+    readonly cause?: DragOrphanCause;
+}
+export declare function dragAnnouncement(input: AnnouncementInput): DragAnnouncement;
+export declare const DRAG_ORPHAN_CAUSES: readonly [
+    "pointer-capture-lost",
+    "pointer-cancel",
+    "element-disconnected",
+    "permission-revoked",
+    "document-hidden",
+    "window-blur",
+    "watchdog-timeout",
+    "zone-unregistered",
+    "context-menu",
+    "data-source-replaced",
+    "controller-disposed"
+];
+export type DragOrphanCause = (typeof DRAG_ORPHAN_CAUSES)[number];
+export declare const DRAG_ORPHAN_END_REASONS: Readonly<Record<DragOrphanCause, RowDragEndReason>>;
+export interface DragAbortSink {
+    abort(reason: RowDragEndReason, cause: DragOrphanCause): void;
+    alive(): boolean;
+}
+export interface TrackedDrag {
+    readonly dragId: string;
+    readonly pointerId: number | null;
+    readonly idleTicks: number;
+    readonly causes: readonly DragOrphanCause[];
+}
+export interface DragSafetyStats {
+    readonly tracked: number;
+    readonly live: number;
+    readonly aborts: number;
+    readonly abortsByCause: Readonly<Record<DragOrphanCause, number>>;
+    readonly ignored: number;
+    readonly redundant: number;
+    readonly sinkThrows: number;
+    readonly swept: number;
+    readonly watchdogTimeouts: number;
+}
+export interface DragSafetyMonitor {
+    track(dragId: string, sink: DragAbortSink, pointerId?: number | null): boolean;
+    heartbeat(dragId: string): void;
+    signal(cause: DragOrphanCause, options?: {
+        readonly dragId?: string;
+        readonly pointerId?: number;
+    }): readonly string[];
+    tick(): readonly string[];
+    sweep(): readonly string[];
+    stuckDrags(): readonly string[];
+    live(): readonly TrackedDrag[];
+    stats(): DragSafetyStats;
+    abortAll(cause?: DragOrphanCause): readonly string[];
+}
+export interface DragSafetyConfig {
+    readonly watchdogTicks?: number;
+}
+export declare const DEFAULT_WATCHDOG_TICKS = 60;
+export declare function createDragSafetyMonitor(config?: DragSafetyConfig): DragSafetyMonitor;
+export declare function rowDragAbortSink(controller: {
+    end(reason: RowDragEndReason): {
+        readonly ended: boolean;
+    };
+    session(): {
+        readonly phase: string;
+    } | null;
+}): DragAbortSink;
+export interface DragSafetyReport {
+    readonly live: number;
+    readonly stuck: readonly string[];
+    readonly aborts: number;
+    readonly topCauses: readonly {
+        readonly cause: DragOrphanCause;
+        readonly count: number;
+    }[];
+    readonly watchdogTicks: number;
+    readonly stats: DragSafetyStats;
+}
+export declare function dragSafetyReport(monitor: DragSafetyMonitor, watchdogTicks?: number): DragSafetyReport;

package/dist/types/components/grid/core/row-drag/drop-zones.d.ts

@@ -0,0 +1,266 @@
+import type { RowDragItem } from './unmanaged-drag.ts';
+export declare const ROW_DROP_ZONE_KINDS: readonly [
+    "grid",
+    "external"
+];
+export type RowDropZoneKind = (typeof ROW_DROP_ZONE_KINDS)[number];
+export declare const ROW_TRANSFER_MODES: readonly [
+    "move",
+    "copy"
+];
+export type RowTransferMode = (typeof ROW_TRANSFER_MODES)[number];
+export declare const ROW_TRANSFER_ATOMICITIES: readonly [
+    "all-or-nothing",
+    "best-effort"
+];
+export type RowTransferAtomicity = (typeof ROW_TRANSFER_ATOMICITIES)[number];
+export declare const ROW_DUPLICATE_ID_POLICIES: readonly [
+    "refuse",
+    "skip",
+    "replace"
+];
+export type RowDuplicateIdPolicy = (typeof ROW_DUPLICATE_ID_POLICIES)[number];
+export declare const ROW_FIELD_TYPES: readonly [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "any"
+];
+export type RowFieldType = (typeof ROW_FIELD_TYPES)[number];
+export declare const ROW_TRANSFER_REFUSAL_REASONS: readonly [
+    "unknown-zone",
+    "zone-removed",
+    "zone-not-accepting",
+    "wrong-kind",
+    "self-transfer",
+    "schema-mismatch",
+    "permission-denied",
+    "permission-error",
+    "duplicate-id",
+    "missing-id",
+    "empty-transfer",
+    "source-row-missing",
+    "insert-out-of-range",
+    "partial-failure",
+    "already-settled",
+    "adapter-error",
+    "key-error"
+];
+export type RowTransferRefusalReason = (typeof ROW_TRANSFER_REFUSAL_REASONS)[number];
+export declare const ROW_TRANSFER_ENTRY_STATUSES: readonly [
+    "transferred",
+    "replaced",
+    "refused"
+];
+export type RowTransferEntryStatus = (typeof ROW_TRANSFER_ENTRY_STATUSES)[number];
+export declare const ROW_ZONE_REGISTRATION_REFUSALS: readonly [
+    "duplicate-zone-id",
+    "invalid-zone-id",
+    "invalid-kind",
+    "grid-zone-incomplete",
+    "external-zone-owns-rows"
+];
+export type RowZoneRegistrationRefusal = (typeof ROW_ZONE_REGISTRATION_REFUSALS)[number];
+export interface RowFieldSpec {
+    readonly field: string;
+    readonly type: RowFieldType;
+    readonly required: boolean;
+}
+export interface RowSchema {
+    readonly id: string;
+    readonly fields: readonly RowFieldSpec[];
+    readonly allowExtraFields: boolean;
+}
+export declare const ROW_SCHEMA_ISSUE_KINDS: readonly [
+    "missing-required",
+    "wrong-type",
+    "extra-field",
+    "not-an-object"
+];
+export type RowSchemaIssueKind = (typeof ROW_SCHEMA_ISSUE_KINDS)[number];
+export interface RowSchemaIssue {
+    readonly kind: RowSchemaIssueKind;
+    readonly field: string;
+    readonly expected: RowFieldType | null;
+    readonly actual: string;
+}
+export declare function checkRowSchema(row: unknown, schema: RowSchema): readonly RowSchemaIssue[];
+export interface RowDropPermissionRequest<TData> {
+    readonly sourceZoneId: string;
+    readonly targetZoneId: string;
+    readonly mode: RowTransferMode;
+    readonly rowKey: string;
+    readonly row: TData;
+    readonly context: unknown;
+}
+export type RowDropPermission = {
+    readonly allow: true;
+} | {
+    readonly allow: false;
+    readonly detail: string;
+};
+export declare const ALLOW_ROW_DROP: RowDropPermission;
+export interface RowDropZone<TData> {
+    readonly id: string;
+    readonly kind: RowDropZoneKind;
+    readonly accepting?: boolean;
+    readonly rows?: () => readonly TData[];
+    readonly getRowKey?: (row: TData, index: number) => string;
+    readonly schema?: RowSchema;
+    readonly permit?: (request: RowDropPermissionRequest<TData>) => RowDropPermission;
+    readonly adapt?: (row: TData, sourceZoneId: string) => TData;
+    readonly consumes?: boolean;
+}
+export interface RegisteredRowDropZone<TData> {
+    readonly zone: RowDropZone<TData>;
+    readonly registeredAt: number;
+}
+export type RowZoneRegistrationResult = {
+    readonly outcome: 'added';
+    readonly zoneId: string;
+    readonly generation: number;
+} | {
+    readonly outcome: 'refused';
+    readonly zoneId: string;
+    readonly reason: RowZoneRegistrationRefusal;
+    readonly detail: string;
+};
+export interface RowDropZoneRegistry<TData> {
+    add(zone: RowDropZone<TData>): RowZoneRegistrationResult;
+    remove(zoneId: string): boolean;
+    get(zoneId: string): RegisteredRowDropZone<TData> | null;
+    list(): readonly RegisteredRowDropZone<TData>[];
+    generation(): number;
+    stats(): RowDropZoneStats;
+}
+export interface RowDropZoneStats {
+    readonly zones: number;
+    readonly gridZones: number;
+    readonly externalZones: number;
+    readonly added: number;
+    readonly removed: number;
+    readonly addRefusals: number;
+    readonly generation: number;
+}
+export declare function createRowDropZoneRegistry<TData>(): RowDropZoneRegistry<TData>;
+export interface RowTransferEntry {
+    readonly rowKey: string;
+    readonly status: RowTransferEntryStatus;
+    readonly reason: RowTransferRefusalReason | null;
+    readonly detail: string;
+    readonly schemaIssues: readonly RowSchemaIssue[];
+    readonly sourceIndex: number | null;
+    readonly targetIndex: number | null;
+}
+export interface RowTransferRequest {
+    readonly transferId?: string;
+    readonly sourceZoneId: string;
+    readonly targetZoneId: string;
+    readonly mode: RowTransferMode;
+    readonly rowKeys: readonly string[];
+    readonly insertIndex?: number;
+    readonly atomicity?: RowTransferAtomicity;
+    readonly duplicateIds?: RowDuplicateIdPolicy;
+    readonly context?: unknown;
+}
+export declare function rowTransferRequestFromDragItem<TData>(item: RowDragItem<TData>, targetZoneId: string, options?: Omit<RowTransferRequest, 'sourceZoneId' | 'targetZoneId' | 'rowKeys' | 'mode'> & {
+    readonly mode?: RowTransferMode;
+}): RowTransferRequest;
+export interface RowTransferPlan<TData> {
+    readonly transferId: string;
+    readonly sourceZoneId: string;
+    readonly targetZoneId: string;
+    readonly targetKind: RowDropZoneKind;
+    readonly mode: RowTransferMode;
+    readonly atomicity: RowTransferAtomicity;
+    readonly duplicateIds: RowDuplicateIdPolicy;
+    readonly insertIndex: number;
+    readonly generation: number;
+    readonly entries: readonly RowTransferEntry[];
+    readonly payload: readonly TData[];
+    readonly removesFromSource: boolean;
+}
+export type RowTransferPlanResult<TData> = {
+    readonly outcome: 'planned';
+    readonly plan: RowTransferPlan<TData>;
+} | {
+    readonly outcome: 'refused';
+    readonly reason: RowTransferRefusalReason;
+    readonly detail: string;
+    readonly entries: readonly RowTransferEntry[];
+};
+export type RowTransferTargetResult<TData> = {
+    readonly kind: 'grid';
+    readonly zoneId: string;
+    readonly rowsBefore: readonly TData[];
+    readonly rowsAfter: readonly TData[];
+} | {
+    readonly kind: 'external';
+    readonly zoneId: string;
+    readonly delivered: readonly TData[];
+    readonly consumed: boolean;
+};
+export interface RowTransferCommit<TData> {
+    readonly transferId: string;
+    readonly mode: RowTransferMode;
+    readonly sourceZoneId: string;
+    readonly sourceRowsBefore: readonly TData[];
+    readonly sourceRowsAfter: readonly TData[];
+    readonly target: RowTransferTargetResult<TData>;
+    readonly transferred: readonly RowTransferEntry[];
+    readonly refused: readonly RowTransferEntry[];
+    readonly entries: readonly RowTransferEntry[];
+}
+export type RowTransferCommitResult<TData> = {
+    readonly outcome: 'committed';
+    readonly commit: RowTransferCommit<TData>;
+} | {
+    readonly outcome: 'refused';
+    readonly reason: RowTransferRefusalReason;
+    readonly detail: string;
+    readonly entries: readonly RowTransferEntry[];
+};
+export declare function planRowTransfer<TData>(registry: RowDropZoneRegistry<TData>, request: RowTransferRequest): RowTransferPlanResult<TData>;
+export declare function commitRowTransfer<TData>(registry: RowDropZoneRegistry<TData>, plan: RowTransferPlan<TData>): RowTransferCommitResult<TData>;
+export interface RowTransferSinks<TData> {
+    applySource(rows: readonly TData[], commit: RowTransferCommit<TData>): void;
+    applyTarget(target: RowTransferTargetResult<TData>, commit: RowTransferCommit<TData>): void;
+    revertTarget?(target: RowTransferTargetResult<TData>, commit: RowTransferCommit<TData>): void;
+}
+export declare const ROW_TRANSFER_APPLY_OUTCOMES: readonly [
+    "applied",
+    "reverted",
+    "compromised"
+];
+export type RowTransferApplyOutcomeKind = (typeof ROW_TRANSFER_APPLY_OUTCOMES)[number];
+export type RowTransferApplyOutcome = {
+    readonly outcome: 'applied';
+    readonly sourceWritten: boolean;
+    readonly targetWritten: boolean;
+} | {
+    readonly outcome: 'reverted';
+    readonly failedSide: 'source' | 'target';
+    readonly error: string;
+    readonly targetUndone: boolean;
+} | {
+    readonly outcome: 'compromised';
+    readonly failedSide: 'source';
+    readonly error: string;
+    readonly revertError: string;
+};
+export declare function applyRowTransfer<TData>(commit: RowTransferCommit<TData>, sinks: RowTransferSinks<TData>): RowTransferApplyOutcome;
+export interface RowTransferReport {
+    readonly transferId: string;
+    readonly mode: RowTransferMode;
+    readonly sourceZoneId: string;
+    readonly targetZoneId: string;
+    readonly targetKind: RowDropZoneKind;
+    readonly transferred: number;
+    readonly replaced: number;
+    readonly refused: number;
+    readonly refusalsByReason: Readonly<Partial<Record<RowTransferRefusalReason, number>>>;
+    readonly sourceDelta: number;
+    readonly targetDelta: number | null;
+}
+export declare function rowTransferReport<TData>(commit: RowTransferCommit<TData>): RowTransferReport;

package/dist/types/components/grid/core/row-drag/reorder.d.ts

@@ -0,0 +1,12 @@
+export type RowDropPosition = 'above' | 'below';
+export interface RowDragState {
+    sourceIndex: number;
+    overIndex: number | null;
+    position: RowDropPosition;
+}
+export declare function beginRowDrag(sourceIndex: number): RowDragState;
+export declare function updateRowDragOver(state: RowDragState, overIndex: number | null, position: RowDropPosition): RowDragState;
+export declare function computeInsertionIndex(overIndex: number | null, position: RowDropPosition): number | null;
+export declare function dropInsertionIndex(state: RowDragState): number | null;
+export declare function isNoopDrop(sourceIndex: number, insertionIndex: number | null): boolean;
+export declare function reorderRows<T>(rows: readonly T[], sourceIndex: number, insertionIndex: number | null): T[];