@anzusystems/common-admin 1.47.0-beta.359 → 1.47.0-beta.360

package/dist/labs.d.ts

@@ -88,6 +88,18 @@ declare type __VLS_PrettifyLocal_3<T> = {
     [K in keyof T]: T[K];
 } & {};
 
+declare type __VLS_PrettifyLocal_4<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+declare type __VLS_PrettifyLocal_5<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+declare type __VLS_PrettifyLocal_6<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
 declare type __VLS_Props = {
     enableTop?: boolean;
     hideButtons?: boolean;
@@ -110,6 +122,8 @@ declare type __VLS_Props_11 = {
     hideRecordsPerPage?: boolean;
 };
 
+declare type __VLS_Props_12 = Props_4;
+
 declare type __VLS_Props_2 = {
     hideButtons?: boolean;
     formName?: string;
@@ -183,6 +197,10 @@ declare type __VLS_PublicProps_3 = {
     'modelValue'?: number;
 } & __VLS_Props_10;
 
+declare type __VLS_PublicProps_4 = {
+    modelValue: boolean;
+} & __VLS_Props_12;
+
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: Partial<Record<string, (_: {
@@ -266,6 +284,39 @@ itemsPerPageOptions: number[];
 hideRecordsPerPage: boolean;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
 
+declare interface AddButtonSlotProps {
+    readonly: boolean;
+    disabled: boolean;
+    props: {
+        onClick: () => void;
+    };
+    actions: {
+        add: () => void;
+    };
+}
+
+declare interface AddButtonSlotProps_2 {
+    readonly: boolean;
+    disabled: boolean;
+    props: {
+        onClick: () => void;
+    };
+    actions: {
+        add: () => void;
+    };
+}
+
+declare interface AddButtonSlotProps_3 {
+    readonly: boolean;
+    disabled: boolean;
+    props: {
+        onClick: () => void;
+    };
+    actions: {
+        add: () => void;
+    };
+}
+
 export declare const AFilterBooleanSelect: DefineComponent<__VLS_Props_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
 change: () => any;
 }, string, PublicProps, Readonly<__VLS_Props_3> & Readonly<{
@@ -410,8 +461,158 @@ export declare const AFormRemoteAutocomplete: <T extends string | number>(__VLS_
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 
+export declare const AListEditor: <TItem extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_4<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal_4<Pick<Partial<{}> & Omit<{
+        readonly onDeleted?: ((item: ListViewItem<TItem>) => any) | undefined;
+        readonly onClose?: ((item: ListViewItem<TItem>) => any) | undefined;
+        readonly onEdit?: ((item: ListViewItem<TItem>) => any) | undefined;
+        readonly onAdd?: ((positionHint: PositionHint | undefined) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: TItem[]) => any) | undefined;
+        readonly "onUpdate:unsavedKeys"?: ((value: Set<ListEditorKey>) => any) | undefined;
+        readonly "onItem-saved"?: ((item: ListViewItem<TItem>) => any) | undefined;
+        readonly "onItem-expand"?: ((item: ListViewItem<TItem>, expanded: boolean) => any) | undefined;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onUpdate:modelValue" | "onClose" | "onEdit" | "onAdd" | "onDeleted" | "onUpdate:unsavedKeys" | "onItem-saved" | "onItem-expand"> & ({
+        modelValue: TItem[];
+        unsavedKeys?: Set<ListEditorKey>;
+    } & Props<TItem>) & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<    {
+    addItem: (data: TItem, positionHint?: PositionHint) => TItem[];
+    deleteItem: (idOrItem: ListEditorKey | TItem) => TItem[];
+    updateItem: (idOrItem: ListEditorKey | TItem, data: TItem) => TItem[];
+    moveItem: (fromIndex: number, toIndex: number) => TItem[];
+    recalculatePositions: (items: TItem[]) => TItem[];
+    viewItems: ComputedRef<ListViewItem<TItem>[]>;
+    resetDirtyBaseline: () => void;
+    hasUnsavedChanges: ComputedRef<boolean>;
+    unsavedCount: ComputedRef<number>;
+    clearUnsavedState: (key?: ListEditorKey) => void;
+    }>): void;
+    attrs: any;
+    slots: Readonly<{
+        header?: (props: HeaderSlotProps) => unknown;
+        empty?: (props: EmptySlotProps) => unknown;
+        'add-button'?: (props: AddButtonSlotProps) => unknown;
+        item?: (props: RowSlotProps<TItem>) => unknown;
+        'item-compact'?: (props: RowSlotProps<TItem>) => unknown;
+        'item-readonly'?: (props: RowSlotProps<TItem>) => unknown;
+        'item-status'?: (props: RowSlotProps<TItem>) => unknown;
+        'item-actions'?: (props: RowSlotProps<TItem>) => unknown;
+        'item-footer'?: (props: RowSlotProps<TItem>) => unknown;
+        'before-item'?: (props: RowSlotProps<TItem>) => unknown;
+        'after-item'?: (props: RowSlotProps<TItem>) => unknown;
+    }> & {
+        header?: (props: HeaderSlotProps) => unknown;
+        empty?: (props: EmptySlotProps) => unknown;
+        'add-button'?: (props: AddButtonSlotProps) => unknown;
+        item?: (props: RowSlotProps<TItem>) => unknown;
+        'item-compact'?: (props: RowSlotProps<TItem>) => unknown;
+        'item-readonly'?: (props: RowSlotProps<TItem>) => unknown;
+        'item-status'?: (props: RowSlotProps<TItem>) => unknown;
+        'item-actions'?: (props: RowSlotProps<TItem>) => unknown;
+        'item-footer'?: (props: RowSlotProps<TItem>) => unknown;
+        'before-item'?: (props: RowSlotProps<TItem>) => unknown;
+        'after-item'?: (props: RowSlotProps<TItem>) => unknown;
+    };
+    emit: (((evt: "deleted", item: ListViewItem<TItem>) => void) & ((evt: "close", item: ListViewItem<TItem>) => void) & ((evt: "edit", item: ListViewItem<TItem>) => void) & ((evt: "add", positionHint: PositionHint | undefined) => void) & ((evt: "item-saved", item: ListViewItem<TItem>) => void) & ((evt: "item-expand", item: ListViewItem<TItem>, expanded: boolean) => void)) & (((evt: "update:modelValue", value: TItem[]) => void) & ((evt: "update:unsavedKeys", value: Set<ListEditorKey>) => void));
+}>) => VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+
 declare type AllowedFilterValues = number | number[] | string | string[] | null | undefined | boolean;
 
+export declare const ANestedSortableListEditor: <TItem extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_6<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal_6<Pick<Partial<{}> & Omit<{
+        readonly onDeleted?: ((item: NestedViewItem<TItem>) => any) | undefined;
+        readonly onClose?: ((item: NestedViewItem<TItem>) => any) | undefined;
+        readonly onEdit?: ((item: NestedViewItem<TItem>) => any) | undefined;
+        readonly onAdd?: ((hint: NestedPositionHint | undefined) => any) | undefined;
+        readonly onIndent?: ((item: NestedViewItem<TItem>) => any) | undefined;
+        readonly onOutdent?: ((item: NestedViewItem<TItem>) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: NestedTree<TItem>) => any) | undefined;
+        readonly "onUpdate:mode"?: ((value: ReorderMode_2) => any) | undefined;
+        readonly "onUpdate:unsavedKeys"?: ((value: Set<ListEditorKey>) => any) | undefined;
+        readonly "onItem-saved"?: ((item: NestedViewItem<TItem>) => any) | undefined;
+        readonly "onItem-expand"?: ((item: NestedViewItem<TItem>, expanded: boolean) => any) | undefined;
+        readonly "onReorder-start"?: (() => any) | undefined;
+        readonly "onReorder-cancel"?: (() => any) | undefined;
+        readonly "onReorder-applied"?: ((tree: NestedTree<TItem>) => any) | undefined;
+        readonly "onReorder-apply-error"?: ((error: unknown) => any) | undefined;
+        readonly "onReorder-end"?: (() => any) | undefined;
+        readonly "onAdd-child"?: ((parent: NestedViewItem<TItem>) => any) | undefined;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onUpdate:modelValue" | "onClose" | "onUpdate:mode" | "onEdit" | "onAdd" | "onDeleted" | "onUpdate:unsavedKeys" | "onItem-saved" | "onItem-expand" | "onReorder-start" | "onReorder-cancel" | "onReorder-applied" | "onReorder-apply-error" | "onReorder-end" | "onIndent" | "onOutdent" | "onAdd-child"> & ({
+        modelValue: NestedTree<TItem>;
+        mode?: ReorderMode_2;
+        unsavedKeys?: Set<ListEditorKey>;
+    } & Props_3<TItem>) & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<    {
+    addItem: (data: TItem, hint?: PositionHint & {
+    parentId?: ListEditorKey | null;
+    asFirstChild?: boolean;
+    childrenAllowed?: boolean;
+    }) => NestedTree<TItem>;
+    addAfterId: (targetId: ListEditorKey | null, data: TItem, childrenAllowed: boolean) => NestedTree<TItem>;
+    addChildToId: (targetId: ListEditorKey, data: TItem, childrenAllowed: boolean) => NestedTree<TItem>;
+    removeById: (id: ListEditorKey) => void;
+    updateData: (id: ListEditorKey, data: TItem, _children?: unknown, _position?: unknown, _markUnsaved?: unknown) => void;
+    updateItem: (id: ListEditorKey, data: TItem) => NestedTree<TItem>;
+    deleteItem: (id: ListEditorKey) => NestedTree<TItem>;
+    moveUp: (id: ListEditorKey) => NestedTree<TItem> | null;
+    moveDown: (id: ListEditorKey) => NestedTree<TItem> | null;
+    moveTop: (id: ListEditorKey) => NestedTree<TItem> | null;
+    moveBottom: (id: ListEditorKey) => NestedTree<TItem> | null;
+    indent: (id: ListEditorKey) => NestedTree<TItem> | null;
+    outdent: (id: ListEditorKey) => NestedTree<TItem> | null;
+    moveTo: (id: ListEditorKey, targetParentId: ListEditorKey | null, targetIndex: number) => NestedTree<TItem> | null;
+    recalculatePositions: (model: NestedTree<TItem>) => NestedTree<TItem>;
+    viewItems: ComputedRef<NestedViewItem<TItem>[]>;
+    resetDirtyBaseline: () => void;
+    hasUnsavedChanges: ComputedRef<boolean>;
+    unsavedCount: ComputedRef<number>;
+    clearUnsavedState: (key?: ListEditorKey) => void;
+    enterReorderMode: () => void;
+    cancelReorderMode: () => void;
+    applyReorder: () => Promise<void>;
+    expand: (id: ListEditorKey) => Set<ListEditorKey> & Omit<Set<ListEditorKey>, keyof Set<any>>;
+    collapse: (id: ListEditorKey) => boolean;
+    toggleExpand: (id: ListEditorKey) => void;
+    expandDetail: (id: ListEditorKey) => Set<ListEditorKey> & Omit<Set<ListEditorKey>, keyof Set<any>>;
+    collapseDetail: (id: ListEditorKey) => boolean;
+    }>): void;
+    attrs: any;
+    slots: Readonly<{
+        header?: (props: HeaderSlotProps_3) => unknown;
+        'reorder-toggle'?: (props: ReorderToggleSlotProps_2) => unknown;
+        'reorder-toolbar'?: (props: ToolbarSlotProps_2) => unknown;
+        empty?: (props: EmptySlotProps_3) => unknown;
+        'add-button'?: (props: AddButtonSlotProps_3) => unknown;
+        item?: (props: RowSlotProps_3<TItem>) => unknown;
+        'item-compact'?: (props: RowSlotProps_3<TItem>) => unknown;
+        'item-readonly'?: (props: RowSlotProps_3<TItem>) => unknown;
+        'item-status'?: (props: RowSlotProps_3<TItem>) => unknown;
+        'item-footer'?: (props: RowSlotProps_3<TItem>) => unknown;
+        'item-actions'?: (props: RowSlotProps_3<TItem>) => unknown;
+        'before-item'?: (props: RowSlotProps_3<TItem>) => unknown;
+        'after-item'?: (props: RowSlotProps_3<TItem>) => unknown;
+    }> & {
+        header?: (props: HeaderSlotProps_3) => unknown;
+        'reorder-toggle'?: (props: ReorderToggleSlotProps_2) => unknown;
+        'reorder-toolbar'?: (props: ToolbarSlotProps_2) => unknown;
+        empty?: (props: EmptySlotProps_3) => unknown;
+        'add-button'?: (props: AddButtonSlotProps_3) => unknown;
+        item?: (props: RowSlotProps_3<TItem>) => unknown;
+        'item-compact'?: (props: RowSlotProps_3<TItem>) => unknown;
+        'item-readonly'?: (props: RowSlotProps_3<TItem>) => unknown;
+        'item-status'?: (props: RowSlotProps_3<TItem>) => unknown;
+        'item-footer'?: (props: RowSlotProps_3<TItem>) => unknown;
+        'item-actions'?: (props: RowSlotProps_3<TItem>) => unknown;
+        'before-item'?: (props: RowSlotProps_3<TItem>) => unknown;
+        'after-item'?: (props: RowSlotProps_3<TItem>) => unknown;
+    };
+    emit: (((evt: "deleted", item: NestedViewItem<TItem>) => void) & ((evt: "close", item: NestedViewItem<TItem>) => void) & ((evt: "edit", item: NestedViewItem<TItem>) => void) & ((evt: "add", hint: NestedPositionHint | undefined) => void) & ((evt: "indent", item: NestedViewItem<TItem>) => void) & ((evt: "outdent", item: NestedViewItem<TItem>) => void) & ((evt: "item-saved", item: NestedViewItem<TItem>) => void) & ((evt: "item-expand", item: NestedViewItem<TItem>, expanded: boolean) => void) & ((evt: "reorder-start") => void) & ((evt: "reorder-cancel") => void) & ((evt: "reorder-applied", tree: NestedTree<TItem>) => void) & ((evt: "reorder-apply-error", error: unknown) => void) & ((evt: "reorder-end") => void) & ((evt: "add-child", parent: NestedViewItem<TItem>) => void)) & (((evt: "update:modelValue", value: NestedTree<TItem>) => void) & ((evt: "update:mode", value: ReorderMode_2) => void) & ((evt: "update:unsavedKeys", value: Set<ListEditorKey>) => void));
+}>) => VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+
 declare interface AnzuUserAndTimeTrackingAware extends CreatedByAware {
     createdAt: DatetimeUTC;
     modifiedAt: DatetimeUTC;
@@ -422,6 +623,77 @@ declare interface AnzuUserMinimal extends BaseUser {
     id: IntegerId;
 }
 
+export declare const ASortableListEditor: <TItem extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_5<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal_5<Pick<Partial<{}> & Omit<{
+        readonly onDeleted?: ((item: ListViewItem<TItem>) => any) | undefined;
+        readonly onClose?: ((item: ListViewItem<TItem>) => any) | undefined;
+        readonly onEdit?: ((item: ListViewItem<TItem>) => any) | undefined;
+        readonly onAdd?: ((positionHint: PositionHint | undefined) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: TItem[]) => any) | undefined;
+        readonly "onUpdate:mode"?: ((value: ReorderMode) => any) | undefined;
+        readonly "onUpdate:unsavedKeys"?: ((value: Set<ListEditorKey>) => any) | undefined;
+        readonly "onItem-saved"?: ((item: ListViewItem<TItem>) => any) | undefined;
+        readonly "onItem-expand"?: ((item: ListViewItem<TItem>, expanded: boolean) => any) | undefined;
+        readonly "onReorder-start"?: (() => any) | undefined;
+        readonly "onReorder-cancel"?: (() => any) | undefined;
+        readonly "onReorder-applied"?: ((items: TItem[]) => any) | undefined;
+        readonly "onReorder-apply-error"?: ((error: unknown) => any) | undefined;
+        readonly "onReorder-end"?: (() => any) | undefined;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onUpdate:modelValue" | "onClose" | "onUpdate:mode" | "onEdit" | "onAdd" | "onDeleted" | "onUpdate:unsavedKeys" | "onItem-saved" | "onItem-expand" | "onReorder-start" | "onReorder-cancel" | "onReorder-applied" | "onReorder-apply-error" | "onReorder-end"> & ({
+        modelValue: TItem[];
+        mode?: ReorderMode;
+        unsavedKeys?: Set<ListEditorKey>;
+    } & Props_2<TItem>) & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<    {
+    addItem: (data: TItem, positionHint?: PositionHint) => TItem[];
+    deleteItem: (idOrItem: ListEditorKey | TItem) => TItem[];
+    updateItem: (idOrItem: ListEditorKey | TItem, data: TItem) => TItem[];
+    moveItem: (fromIndex: number, toIndex: number) => TItem[];
+    recalculatePositions: (items: TItem[]) => TItem[];
+    viewItems: ComputedRef<ListViewItem<TItem>[]>;
+    resetDirtyBaseline: () => void;
+    hasUnsavedChanges: ComputedRef<boolean>;
+    unsavedCount: ComputedRef<number>;
+    clearUnsavedState: (key?: ListEditorKey) => void;
+    enterReorderMode: () => void;
+    cancelReorderMode: () => void;
+    applyReorder: () => Promise<void>;
+    }>): void;
+    attrs: any;
+    slots: Readonly<{
+        header?: (props: HeaderSlotProps_2) => unknown;
+        'reorder-toggle'?: (props: ReorderToggleSlotProps) => unknown;
+        'reorder-toolbar'?: (props: ToolbarSlotProps) => unknown;
+        empty?: (props: EmptySlotProps_2) => unknown;
+        'add-button'?: (props: AddButtonSlotProps_2) => unknown;
+        item?: (props: RowSlotProps_2<TItem>) => unknown;
+        'item-compact'?: (props: RowSlotProps_2<TItem>) => unknown;
+        'item-readonly'?: (props: RowSlotProps_2<TItem>) => unknown;
+        'item-status'?: (props: RowSlotProps_2<TItem>) => unknown;
+        'item-actions'?: (props: RowSlotProps_2<TItem>) => unknown;
+        'item-footer'?: (props: RowSlotProps_2<TItem>) => unknown;
+        'before-item'?: (props: RowSlotProps_2<TItem>) => unknown;
+        'after-item'?: (props: RowSlotProps_2<TItem>) => unknown;
+    }> & {
+        header?: (props: HeaderSlotProps_2) => unknown;
+        'reorder-toggle'?: (props: ReorderToggleSlotProps) => unknown;
+        'reorder-toolbar'?: (props: ToolbarSlotProps) => unknown;
+        empty?: (props: EmptySlotProps_2) => unknown;
+        'add-button'?: (props: AddButtonSlotProps_2) => unknown;
+        item?: (props: RowSlotProps_2<TItem>) => unknown;
+        'item-compact'?: (props: RowSlotProps_2<TItem>) => unknown;
+        'item-readonly'?: (props: RowSlotProps_2<TItem>) => unknown;
+        'item-status'?: (props: RowSlotProps_2<TItem>) => unknown;
+        'item-actions'?: (props: RowSlotProps_2<TItem>) => unknown;
+        'item-footer'?: (props: RowSlotProps_2<TItem>) => unknown;
+        'before-item'?: (props: RowSlotProps_2<TItem>) => unknown;
+        'after-item'?: (props: RowSlotProps_2<TItem>) => unknown;
+    };
+    emit: (((evt: "deleted", item: ListViewItem<TItem>) => void) & ((evt: "close", item: ListViewItem<TItem>) => void) & ((evt: "edit", item: ListViewItem<TItem>) => void) & ((evt: "add", positionHint: PositionHint | undefined) => void) & ((evt: "item-saved", item: ListViewItem<TItem>) => void) & ((evt: "item-expand", item: ListViewItem<TItem>, expanded: boolean) => void) & ((evt: "reorder-start") => void) & ((evt: "reorder-cancel") => void) & ((evt: "reorder-applied", items: TItem[]) => void) & ((evt: "reorder-apply-error", error: unknown) => void) & ((evt: "reorder-end") => void)) & (((evt: "update:modelValue", value: TItem[]) => void) & ((evt: "update:mode", value: ReorderMode) => void) & ((evt: "update:unsavedKeys", value: Set<ListEditorKey>) => void));
+}>) => VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+
 export declare const ASubjectSelect: <TItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_3<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal_3<Pick<Partial<{}> & Omit<{
         readonly "onUpdate:modelValue"?: ((data: boolean) => any) | undefined;
@@ -473,6 +745,19 @@ export declare const ASubjectSelect: <TItem>(__VLS_props: NonNullable<Awaited<ty
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 
+export declare const AUnsavedConfirmDialog: DefineComponent<__VLS_PublicProps_4, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: boolean) => any;
+resolve: (discard: boolean) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps_4> & Readonly<{
+"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+onResolve?: ((discard: boolean) => any) | undefined;
+}>, {
+title: string;
+body: string;
+stayLabel: string;
+discardLabel: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
 export declare type AxiosClientFn = () => AxiosInstance;
 
 declare interface BaseUser {
@@ -569,11 +854,63 @@ declare type DatetimeUTC = string;
  */
 declare type DatetimeUTCNullable = string | null;
 
+declare interface DecoratedNestedViewItem<T> extends NestedViewItem<T> {
+    editing: boolean;
+    expanded: boolean;
+    childrenExpanded: boolean;
+    loading: boolean;
+    dirty: boolean;
+    moved: boolean;
+    unsaved: boolean;
+}
+
+declare interface DecoratedViewItem<T> extends ListViewItem<T> {
+    editing: boolean;
+    expanded: boolean;
+    loading: boolean;
+    dirty: boolean;
+}
+
+declare interface DecoratedViewItem_2<T> extends ListViewItem<T> {
+    editing: boolean;
+    expanded: boolean;
+    loading: boolean;
+    dirty: boolean;
+    moved: boolean;
+    unsaved: boolean;
+    canMoveUp: boolean;
+    canMoveDown: boolean;
+}
+
 /**
  * UUID v4 as string.
  */
 declare type DocId = string;
 
+declare interface EmptySlotProps {
+    readonly: boolean;
+    disabled: boolean;
+    actions: {
+        add: () => void;
+    };
+}
+
+declare interface EmptySlotProps_2 {
+    readonly: boolean;
+    disabled: boolean;
+    actions: {
+        add: () => void;
+    };
+}
+
+declare interface EmptySlotProps_3 {
+    readonly: boolean;
+    disabled: boolean;
+    actions: {
+        add: () => void;
+    };
+}
+
 declare type ExecuteRequestParams<T> = {
     urlTemplate?: string;
     urlParams?: UrlParams;
@@ -680,6 +1017,18 @@ declare interface GeneralFilterOptions {
 
 export declare const generateListQuery: (pagination: Ref<Pagination>, filterData: FilterData<any>, filterConfig: FilterConfig<any>) => string;
 
+declare interface HeaderSlotProps {
+    title: string | null;
+}
+
+declare interface HeaderSlotProps_2 extends ReorderToggleSlotProps {
+    title: string | null;
+}
+
+declare interface HeaderSlotProps_3 extends ReorderToggleSlotProps_2 {
+    title: string | null;
+}
+
 /**
  * Integer ID.
  */
@@ -718,6 +1067,37 @@ declare const JobStatus: {
 
 declare type JobStatusType = (typeof JobStatus)[keyof typeof JobStatus];
 
+export declare interface ListEditorApi<TItem> {
+    viewItems: ComputedRef<ListViewItem<TItem>[]>;
+    addItem: (data: TItem, positionHint?: PositionHint) => TItem[];
+    deleteItem: (idOrItem: ListEditorKey | TItem) => TItem[];
+    updateItem: (idOrItem: ListEditorKey | TItem, data: TItem) => TItem[];
+    moveItem: (fromIndex: number, toIndex: number) => TItem[];
+    recalculatePositions: (items: TItem[]) => TItem[];
+}
+
+export declare type ListEditorKey = DocId | IntegerId | string;
+
+export declare const ListEditorValidationKey: InjectionKey<ListEditorValidationRegistry>;
+
+export declare interface ListEditorValidationRegistry {
+    register: (key: ListEditorKey, state: Ref<ListEditorValidationState> | ComputedRef<ListEditorValidationState>) => void;
+    unregister: (key: ListEditorKey) => void;
+}
+
+export declare type ListEditorValidationState = 'valid' | 'invalid' | 'warning' | null;
+
+export declare interface ListViewItem<TItem> {
+    key: ListEditorKey;
+    index: number;
+    raw: TItem;
+    position?: number;
+    moved?: boolean;
+    expanded?: boolean;
+    editing?: boolean;
+    validationState?: ListEditorValidationState;
+}
+
 export declare interface MakeFilterOption<TName extends string = string> {
     name: TName;
     default: AllowedFilterValues;
@@ -733,6 +1113,78 @@ export declare interface MakeFilterOption<TName extends string = string> {
     render?: Partial<FilerRenderOptions>;
 }
 
+export declare interface NestedListEditorApi<TItem extends Record<string, any>> {
+    viewItems: ComputedRef<NestedViewItem<TItem>[]>;
+    findNode: (id: ListEditorKey) => {
+        node: NestedTreeNode<TItem> | null;
+        parent: NestedTreeNode<TItem> | null;
+    };
+    addItem: (data: TItem, hint?: PositionHint & {
+        parentId?: ListEditorKey | null;
+        asFirstChild?: boolean;
+        childrenAllowed?: boolean;
+    }) => NestedTree<TItem>;
+    deleteItem: (id: ListEditorKey) => NestedTree<TItem>;
+    updateItem: (id: ListEditorKey, data: TItem) => NestedTree<TItem>;
+    moveUp: (id: ListEditorKey) => NestedTree<TItem> | null;
+    moveDown: (id: ListEditorKey) => NestedTree<TItem> | null;
+    moveTop: (id: ListEditorKey) => NestedTree<TItem> | null;
+    moveBottom: (id: ListEditorKey) => NestedTree<TItem> | null;
+    indent: (id: ListEditorKey) => NestedTree<TItem> | null;
+    outdent: (id: ListEditorKey) => NestedTree<TItem> | null;
+    moveTo: (id: ListEditorKey, targetParentId: ListEditorKey | null, targetIndex: number) => NestedTree<TItem> | null;
+    recalculatePositions: (model: NestedTree<TItem>) => NestedTree<TItem>;
+    calculateSubtreeDepth: (node: NestedTreeNode<TItem>) => number;
+}
+
+export declare interface NestedPositionHint {
+    parentId?: ListEditorKey | null;
+    afterId?: ListEditorKey;
+    afterIndex?: number;
+    index?: number;
+    asFirstChild?: boolean;
+    childrenAllowed?: boolean;
+}
+
+export declare interface NestedTree<TItem = any> {
+    children: NestedTreeNode<TItem>[];
+    meta: {
+        dirty: boolean;
+    };
+}
+
+/**
+ * Shape-compatible with legacy SortableNestedItem but without the
+ * `SortableItemWithParentDataAware` constraint — so the nested editor can
+ * accept any record shape that has stable keys addressable via configurable
+ * fields (keyField, positionField, parentField). Admin-cms data types like
+ * `LinkedListItemKind` are assignable to this.
+ */
+export declare interface NestedTreeNode<TItem = any> {
+    data: TItem;
+    children?: NestedTreeNode<TItem>[];
+    meta: {
+        dirty: boolean;
+    };
+}
+
+export declare interface NestedViewItem<TItem> extends ListViewItem<TItem> {
+    node: NestedTreeNode<TItem>;
+    depth: number;
+    parent: TItem | null;
+    parentKey: ListEditorKey | null;
+    childrenCount: number;
+    hasChildren: boolean;
+    childrenAllowed: boolean;
+    siblingIndex: number;
+    siblingCount: number;
+    firstInParent: boolean;
+    lastInParent: boolean;
+    canAddChild: boolean;
+    canIndent: boolean;
+    canOutdent: boolean;
+}
+
 export declare interface Pagination {
     sortBy: DatatableSortBy;
     page: number;
@@ -747,11 +1199,330 @@ declare interface PaginationOptions {
     rowsPerPage: number;
 }
 
+export declare interface PositionHint {
+    afterId?: ListEditorKey;
+    afterIndex?: number;
+    index?: number;
+}
+
+declare interface Props<TItem extends Record<string, any>> {
+    keyField?: string;
+    positionField?: string;
+    positionMultiplier?: number;
+    updatePosition?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    error?: string | null;
+    title?: string | null;
+    compactField?: string | null;
+    statusField?: string | null;
+    twoRows?: 'never' | 'mobile' | 'always';
+    chips?: boolean;
+    showAddButton?: boolean;
+    showDeleteButton?: boolean;
+    showEditButton?: boolean;
+    showAddAfterAction?: boolean;
+    addLabel?: string | null;
+    emptyTitle?: string | null;
+    emptyText?: string | null;
+    disableRowClick?: boolean;
+    disableDeleteConfirm?: boolean;
+    deleteConfirmTitle?: string | null;
+    deleteConfirmText?: string | null;
+    closeVariant?: 'auto' | 'icon' | 'labeled';
+    loadingKeys?: Set<ListEditorKey> | null;
+    getValidationState?: (item: TItem, key: ListEditorKey, index: number) => ListEditorValidationState;
+    onDeleteConfirm?: (item: TItem) => Promise<boolean> | boolean;
+    onDelete?: (item: TItem) => Promise<void> | void;
+    onItemSave?: (item: TItem) => Promise<void> | void;
+}
+
+declare interface Props_2<TItem extends Record<string, any>> {
+    keyField?: string;
+    positionField?: string;
+    positionMultiplier?: number;
+    updatePosition?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    error?: string | null;
+    title?: string | null;
+    compactField?: string | null;
+    statusField?: string | null;
+    twoRows?: 'never' | 'mobile' | 'always';
+    chips?: boolean;
+    showAddButton?: boolean;
+    showDeleteButton?: boolean;
+    showEditButton?: boolean;
+    showAddAfterAction?: boolean;
+    addLabel?: string | null;
+    emptyTitle?: string | null;
+    emptyText?: string | null;
+    disableRowClick?: boolean;
+    disableDeleteConfirm?: boolean;
+    deleteConfirmTitle?: string | null;
+    deleteConfirmText?: string | null;
+    closeVariant?: 'auto' | 'icon' | 'labeled';
+    loadingKeys?: Set<ListEditorKey> | null;
+    showReorderToggle?: boolean;
+    disableReorder?: boolean;
+    disableDrag?: boolean;
+    showMoveToPosition?: boolean;
+    /**
+     * Embedded mode — this editor is nested inside another editor's `#item`
+     * slot and follows a shared `v-model:mode` from the outer editor. When
+     * set, the editor:
+     *   - hides its own Reorder button + Cancel/Apply toolbar
+     *   - skips the snapshot/restore (the outer editor's deep snapshot covers
+     *     nested data, so cancel at the top reverts everything)
+     *   - paints lighter chrome so it visually reads as part of the parent row
+     * Pair with `v-model:mode` bound to the same ref the outer editor uses.
+     */
+    embedded?: boolean;
+    /**
+     * Allow rows to remain inline-editable while the editor is in reorder
+     * mode. By default, entering reorder closes any open inline edit and the
+     * `#item` slot body is hidden — this keeps the visual focus on dragging.
+     * Set this when the open row's body needs to render in reorder mode (e.g.
+     * the parent editor of a shared-reorder pair, where the open question
+     * exposes its embedded answers list for dragging).
+     */
+    allowEditInReorder?: boolean;
+    getValidationState?: (item: TItem, key: ListEditorKey, index: number) => ListEditorValidationState;
+    onDeleteConfirm?: (item: TItem) => Promise<boolean> | boolean;
+    onDelete?: (item: TItem) => Promise<void> | void;
+    onItemSave?: (item: TItem) => Promise<void> | void;
+    onReorderApply?: (items: TItem[]) => Promise<void> | void;
+}
+
+declare interface Props_3<TItem extends Record<string, any>> {
+    maxDepth: number;
+    keyField?: string;
+    positionField?: string;
+    parentField?: string;
+    positionMultiplier?: number;
+    readonly?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    error?: string | null;
+    title?: string | null;
+    compactField?: string | null;
+    statusField?: string | null;
+    showAddButton?: boolean;
+    showAddChildButton?: boolean;
+    showDeleteButton?: boolean;
+    showEditButton?: boolean;
+    showAddAfterAction?: boolean;
+    showMoveToPosition?: boolean;
+    showChangeParent?: boolean;
+    showExpandToggle?: boolean;
+    getValidationState?: (item: TItem, key: ListEditorKey, index: number) => ListEditorValidationState;
+    addLabel?: string | null;
+    emptyTitle?: string | null;
+    emptyText?: string | null;
+    disableRowClick?: boolean;
+    disableDeleteConfirm?: boolean;
+    deleteConfirmTitle?: string | null;
+    deleteConfirmText?: string | null;
+    closeVariant?: 'auto' | 'icon' | 'labeled';
+    loadingKeys?: Set<ListEditorKey> | null;
+    showReorderToggle?: boolean;
+    disableReorder?: boolean;
+    disableDrag?: boolean;
+    onDeleteConfirm?: (item: TItem) => Promise<boolean> | boolean;
+    onDelete?: (item: TItem) => Promise<void> | void;
+    onItemSave?: (item: TItem) => Promise<void> | void;
+    onReorderApply?: (tree: NestedTree<TItem>) => Promise<void> | void;
+}
+
+declare interface Props_4 {
+    title?: string;
+    body?: string;
+    stayLabel?: string;
+    discardLabel?: string;
+}
+
+declare type ReorderMode = 'view' | 'reorder';
+
+declare type ReorderMode_2 = 'view' | 'reorder';
+
+export declare type ReorderModeValue = 'view' | 'reorder';
+
+declare interface ReorderToggleSlotProps {
+    mode: ReorderMode;
+    disabled: boolean;
+    hasPendingChanges: boolean;
+    actions: {
+        enterReorderMode: () => void;
+        exitReorderMode: () => void;
+    };
+}
+
+declare interface ReorderToggleSlotProps_2 {
+    mode: ReorderMode_2;
+    disabled: boolean;
+    hasPendingChanges: boolean;
+    actions: {
+        enterReorderMode: () => void;
+        exitReorderMode: () => void;
+    };
+}
+
+declare interface RowActions<TItem> {
+    edit: () => void;
+    save: () => Promise<void> | void;
+    cancel: () => void;
+    close: () => void;
+    delete: () => Promise<void>;
+    addAfter: () => void;
+    toggleExpand: () => void;
+    update: (data: TItem) => TItem[];
+}
+
+declare interface RowActions_2<TItem> {
+    edit: () => void;
+    save: () => Promise<void> | void;
+    cancel: () => void;
+    close: () => void;
+    delete: () => Promise<void>;
+    addAfter: () => void;
+    toggleExpand: () => void;
+    moveUp: () => void;
+    moveDown: () => void;
+    moveTop: () => void;
+    moveBottom: () => void;
+    update: (data: TItem) => TItem[];
+}
+
+declare interface RowActions_3<TItem> {
+    edit: () => void;
+    save: () => Promise<void> | void;
+    cancel: () => void;
+    close: () => void;
+    delete: () => Promise<void>;
+    addAfter: () => void;
+    addChild: () => void;
+    toggleExpand: () => void;
+    toggleDetail: () => void;
+    moveUp: () => void;
+    moveDown: () => void;
+    moveTop: () => void;
+    moveBottom: () => void;
+    indent: () => void;
+    outdent: () => void;
+    update: (data: TItem) => NestedTree<TItem>;
+}
+
+declare interface RowSlotProps<TItem extends Record<string, any>> {
+    item: DecoratedViewItem<TItem> & {
+        validationState: ListEditorValidationState;
+    };
+    raw: TItem;
+    index: number;
+    key: ListEditorKey;
+    readonly: boolean;
+    disabled: boolean;
+    expanded: boolean;
+    editing: boolean;
+    dirty: boolean;
+    /**
+     * Aliases `dirty` on the flat editor (no reorder mode → no `moved` to OR
+     * with). Mirrors the field name on the sortable + nested variants so a
+     * consumer slot template can use the same name across all three editors.
+     */
+    unsaved: boolean;
+    touch: boolean;
+    actions: RowActions<TItem>;
+}
+
+declare interface RowSlotProps_2<TItem extends Record<string, any>> {
+    item: DecoratedViewItem_2<TItem> & {
+        validationState: ListEditorValidationState;
+    };
+    raw: TItem;
+    index: number;
+    key: ListEditorKey;
+    readonly: boolean;
+    disabled: boolean;
+    expanded: boolean;
+    editing: boolean;
+    dirty: boolean;
+    unsaved: boolean;
+    reorderMode: boolean;
+    moved: boolean;
+    canMoveUp: boolean;
+    canMoveDown: boolean;
+    touch: boolean;
+    actions: RowActions_2<TItem>;
+}
+
+declare interface RowSlotProps_3<TItem extends Record<string, any>> {
+    item: DecoratedNestedViewItem<TItem> & {
+        validationState: ListEditorValidationState;
+    };
+    raw: TItem;
+    index: number;
+    key: ListEditorKey;
+    depth: number;
+    parent: TItem | null;
+    parentKey: ListEditorKey | null;
+    childrenCount: number;
+    hasChildren: boolean;
+    childrenAllowed: boolean;
+    firstInParent: boolean;
+    lastInParent: boolean;
+    readonly: boolean;
+    disabled: boolean;
+    expanded: boolean;
+    childrenExpanded: boolean;
+    editing: boolean;
+    dirty: boolean;
+    unsaved: boolean;
+    moved: boolean;
+    reorderMode: boolean;
+    canMoveUp: boolean;
+    canMoveDown: boolean;
+    canIndent: boolean;
+    canOutdent: boolean;
+    canAddChild: boolean;
+    touch: boolean;
+    actions: RowActions_3<TItem>;
+}
+
+export declare interface SharedReorderRegistry {
+    register: (id: symbol, movedCount: ComputedRef<number>, hasPendingChanges: ComputedRef<boolean>) => void;
+    unregister: (id: symbol) => void;
+}
+
+export declare const SharedReorderRegistryKey: InjectionKey<SharedReorderRegistry>;
+
 declare interface SortableItemDataAware {
     id?: DocId | IntegerId;
     position: number;
 }
 
+declare interface SortableItemWithParentDataAware {
+    id: DocId | IntegerId;
+    position: number;
+    parent: DocId | IntegerId | null;
+}
+
+export declare interface SortableNested<TData extends SortableItemWithParentDataAware = any> {
+    children: Array<SortableNestedItem<TData>>;
+    meta: {
+        dirty: boolean;
+    };
+}
+
+export declare interface SortableNestedItem<TData extends SortableItemWithParentDataAware = any> {
+    data: TData;
+    children?: Array<SortableNestedItem> | undefined;
+    meta: {
+        dirty: boolean;
+    };
+}
+
 declare const SortOrder: {
     readonly Asc: "asc";
     readonly Desc: "desc";
@@ -771,6 +1542,30 @@ declare type TimeIntervalSpecialOptionsType = (typeof TimeIntervalSpecialOptions
 /** note: number value represents time interval in minutes, null represent unselected */
 export declare type TimeIntervalToolsValue = number | TimeIntervalSpecialOptionsType | null;
 
+declare interface ToolbarSlotProps {
+    applying: boolean;
+    hasPendingChanges: boolean;
+    movedCount: number;
+    error: string | null;
+    actions: {
+        apply: () => Promise<void>;
+        cancel: () => void;
+    };
+}
+
+declare interface ToolbarSlotProps_2 {
+    applying: boolean;
+    hasPendingChanges: boolean;
+    movedCount: number;
+    error: string | null;
+    actions: {
+        apply: () => Promise<void>;
+        cancel: () => void;
+    };
+}
+
+declare type UnsavedSource = Ref<boolean | Set<unknown> | unknown[] | null | undefined>;
+
 declare type UrlParams = {
     [key: string]: number | string;
 };
@@ -882,6 +1677,92 @@ export declare function useJobApi<JobType extends JobBase = JobBase>(client: ()
     deleteJob: (id: number) => Promise<JobType>;
 };
 
+/**
+ * Flat list editor core. Pure data behavior shared by AListEditor and
+ * ASortableListEditor. Does not touch the DOM, SortableJS, or emits.
+ *
+ * The caller passes a writable ref (typically `defineModel<TItem[]>`).
+ * Mutators write a new array to `model.value` and also return it.
+ * Input items are never mutated — when positions need to change, a new
+ * item object is produced with `{ ...item, [positionField]: n }`.
+ */
+export declare function useListEditor<TItem extends Record<string, any>>(model: Ref<TItem[]>, options?: UseListEditorOptions): ListEditorApi<TItem>;
+
+export declare function useListEditorItemValidation(options: UseListEditorItemValidationOptions): void;
+
+declare interface UseListEditorItemValidationOptions {
+    /**
+     * Stable identity of the row in the editor's v-model. Pass a getter so the
+     * composable can re-register if the key ever swaps.
+     */
+    key: () => ListEditorKey;
+    /**
+     * Reactive validation state. Common shape: a computed reading vuelidate's
+     * `v$.$dirty && v$.$invalid` and returning 'invalid' or null.
+     */
+    state: Ref<ListEditorValidationState> | ComputedRef<ListEditorValidationState> | (() => ListEditorValidationState);
+}
+
+export declare interface UseListEditorOptions {
+    keyField?: string;
+    positionField?: string;
+    positionMultiplier?: number;
+    updatePosition?: boolean;
+}
+
+/**
+ * Nested list editor core. Pure data behavior shared by ANestedSortableListEditor.
+ * Works on a tree of `{ data, children, meta }` nodes — shape-compatible with the
+ * legacy `SortableNested` wrapper so migration can pass existing data through
+ * unchanged. Mutators return a cloned tree and also assign it to `model.value`.
+ */
+export declare function useNestedListEditor<TItem extends Record<string, any>>(model: Ref<NestedTree<TItem>>, options: UseNestedListEditorOptions): NestedListEditorApi<TItem>;
+
+declare interface UseNestedListEditorOptions {
+    keyField?: string;
+    positionField?: string;
+    parentField?: string;
+    positionMultiplier?: number;
+    maxDepth: number;
+    expandedKeys?: Ref<Set<ListEditorKey>>;
+}
+
+/**
+ * Aggregates per-parent child-editor unsaved-keys into one prefix-merged set.
+ * Used by stacked editors (e.g. quiz: questions → answers) so the outer
+ * editor's parent gets a single merged `Set<ListEditorKey>` to thread into a
+ * unsaved-changes guard, without losing per-parent identity.
+ *
+ * Key collision matters: a brand-new question and a brand-new answer both
+ * have `id: 0` from the factory; without the prefix the answers from two
+ * different questions would dedupe into one entry and the count would
+ * under-report. Prefix `${parentKey}:${childKey}` keeps them distinct.
+ *
+ * Usage:
+ *   const childSets = useNestedUnsavedKeys()
+ *   <ChildEditor
+ *     :unsaved-keys="childSets.getForParent(parent.id)"
+ *     @update:unsaved-keys="(s) => childSets.setForParent(parent.id, s)"
+ *   />
+ *   // emit `childSets.merged.value` upward
+ */
+export declare function useNestedUnsavedKeys(): UseNestedUnsavedKeysApi;
+
+export declare interface UseNestedUnsavedKeysApi {
+    /** Set of unsaved keys for one parent row — used as the inner editor's `v-model:unsaved-keys`. */
+    getForParent: (parentKey: ListEditorKey) => Set<ListEditorKey>;
+    /** Push a child editor's unsaved-key set up under `parentKey`. */
+    setForParent: (parentKey: ListEditorKey, set: Set<ListEditorKey>) => void;
+    /**
+     * Aggregated set with prefix-merged keys (`${parentKey}:${childKey}`) so two
+     * different parents can't collide on a shared child key (typical for newly
+     * created rows whose `id` is `0` until the API assigns one).
+     */
+    merged: ComputedRef<Set<ListEditorKey>>;
+    /** Total count across all parents — handy for the parent v-model:unsaved-keys. */
+    count: ComputedRef<number>;
+}
+
 export declare function usePagination(sortKey: string | null, sortOrder?: SortOrderType, options?: Partial<PaginationOptions>, externalPaginationRef?: Ref<Pagination>): UsePaginationReturnType;
 
 declare interface UsePaginationReturnType {
@@ -958,6 +1839,53 @@ export declare function useSubjectSelect<TItem>(datatableConfig: any, datatableH
     submitFilter: () => void;
 };
 
+export declare function useUnsavedChangesGuard(options: UseUnsavedChangesGuardOptions): UseUnsavedChangesGuardApi;
+
+declare interface UseUnsavedChangesGuardApi {
+    hasUnsavedChanges: ComputedRef<boolean>;
+    /**
+     * v-model-bound to the confirm dialog. When the guard wants to ask the user
+     * to confirm leaving, it sets this to true. The confirm dialog reads it.
+     */
+    promptOpen: Ref<boolean>;
+    /**
+     * Resolves the confirm prompt with `discard=true` (proceed) or `false`
+     * (stay). Called by the confirm dialog.
+     */
+    resolvePrompt: (discard: boolean) => void;
+    /**
+     * Manually mark the most recent intent as acknowledged so the next
+     * route/dialog/unload attempt proceeds without prompting. Useful right
+     * before a programmatic navigation that the consumer has already
+     * confirmed.
+     */
+    acknowledge: () => void;
+}
+
+declare interface UseUnsavedChangesGuardOptions {
+    /**
+     * Reactive sources that signal "unsaved" state. Each source's truthiness is
+     * checked: a Set/array is "dirty" when non-empty, a boolean when true, null
+     * or undefined as not dirty.
+     */
+    sources: UnsavedSource[];
+    /**
+     * Block route navigation via vue-router's onBeforeRouteLeave. Default true.
+     * When omitted/false, the route guard is not registered.
+     */
+    guardRoute?: boolean | Ref<boolean>;
+    /**
+     * Block window/tab unload via beforeunload. Default true.
+     */
+    guardWindowUnload?: boolean | Ref<boolean>;
+    /**
+     * Optional Vuetify dialog v-model. When provided, attempts to close the
+     * dialog while dirty are intercepted: dialog stays open until the user
+     * confirms via the confirm dialog or via `acknowledge()`.
+     */
+    guardDialogModel?: Ref<boolean>;
+}
+
 export declare function useUserAdminConfigApi(client: () => AxiosInstance, system: string, entity?: string, endPoint?: string): {
     useFetchUserAdminConfigList: () => UseApiFetchListReturnType<UserAdminConfig<UserAdminConfigDataFilterBookmark | UserAdminConfigDataPinnedWidgets<string>>[]>;
     fetchUserAdminConfig: (id: IntegerId) => Promise<UserAdminConfig<UserAdminConfigDataFilterBookmark | UserAdminConfigDataPinnedWidgets<string>>>;