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

package/dist/labs.d.ts

@@ -0,0 +1,1912 @@
+import { AllowedComponentProps } from 'vue';
+import { AnyFn } from '@vueuse/core';
+import { AxiosInstance } from 'axios';
+import { AxiosRequestConfig } from 'axios';
+import { ComponentCustomProps } from 'vue';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComputedRef } from 'vue';
+import { DefineComponent } from 'vue';
+import { InjectionKey } from 'vue';
+import { Method } from 'axios';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+import { ShallowUnwrapRef } from 'vue';
+import { UseDebounceFnReturn } from '@vueuse/shared';
+import { VNode } from 'vue';
+import { VNodeProps } from 'vue';
+
+declare const __VLS_component: DefineComponent<__VLS_PublicProps, {
+submit: () => void;
+reset: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:datatableHiddenColumns": (value: string[] | undefined) => any;
+"update:showDetail": (value: boolean) => any;
+} & {
+reset: () => any;
+submit: () => any;
+bookmarkLoadAfter: () => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+onReset?: (() => any) | undefined;
+onSubmit?: (() => any) | undefined;
+"onUpdate:datatableHiddenColumns"?: ((value: string[] | undefined) => any) | undefined;
+onBookmarkLoadAfter?: (() => any) | undefined;
+"onUpdate:showDetail"?: ((value: boolean) => any) | undefined;
+}>, {
+userId: IntegerIdNullable;
+client: () => AxiosInstance;
+enableTop: boolean;
+hideButtons: boolean;
+formName: string;
+store: FilterStoreIdentifier | boolean;
+alwaysVisible: boolean;
+hideMore: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_2: DefineComponent<__VLS_PublicProps_2, {
+submit: () => void;
+reset: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:datatableHiddenColumns": (value: string[] | undefined) => any;
+} & {
+reset: () => any;
+submit: () => any;
+bookmarkLoadAfter: () => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps_2> & Readonly<{
+onReset?: (() => any) | undefined;
+onSubmit?: (() => any) | undefined;
+"onUpdate:datatableHiddenColumns"?: ((value: string[] | undefined) => any) | undefined;
+onBookmarkLoadAfter?: (() => any) | undefined;
+}>, {
+userId: IntegerIdNullable;
+client: () => AxiosInstance;
+hideButtons: boolean;
+formName: string;
+disableFilterUrlSync: boolean;
+store: FilterStoreIdentifier | boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_3: DefineComponent<__VLS_Props_8, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+change: () => any;
+}, string, PublicProps, Readonly<__VLS_Props_8> & Readonly<{
+onChange?: (() => any) | undefined;
+}>, {
+placeholder: string;
+dataCy: string;
+allowed: TimeIntervalToolsValue[];
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+declare type __VLS_PrettifyLocal_2<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+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;
+    formName?: string;
+    userId?: IntegerIdNullable | undefined;
+    client?: (() => AxiosInstance) | undefined;
+    store?: FilterStoreIdentifier | boolean;
+    alwaysVisible?: boolean;
+    hideMore?: boolean;
+};
+
+declare type __VLS_Props_10 = {
+    variant?: 'id' | 'createdAt' | 'most-relevant';
+    customOptions?: undefined | DatatableOrderingOptions;
+    paginationUpdateCustomCb?: ((option: DatatableOrderingOption, pagination: Ref<Pagination>) => void) | undefined;
+};
+
+declare type __VLS_Props_11 = {
+    itemsPerPageOptions?: number[];
+    hideRecordsPerPage?: boolean;
+};
+
+declare type __VLS_Props_12 = Props_4;
+
+declare type __VLS_Props_2 = {
+    hideButtons?: boolean;
+    formName?: string;
+    disableFilterUrlSync?: boolean;
+    userId?: IntegerIdNullable | undefined;
+    client?: (() => AxiosInstance) | undefined;
+    store?: FilterStoreIdentifier | boolean;
+};
+
+declare type __VLS_Props_3 = {
+    name: string;
+    allT?: string;
+    trueT?: string;
+    falseT?: string;
+    dataCy?: string;
+};
+
+declare type __VLS_Props_4 = {
+    name: string;
+    dataCy?: string;
+};
+
+declare type __VLS_Props_5 = {
+    name: string;
+    placeholder?: string | undefined;
+    dataCy?: string;
+};
+
+declare type __VLS_Props_6 = {
+    name: string;
+    fetchItemsMinimal: FetchItemsMinimalType;
+    fetchItemsMinimalByIds: FetchItemsMinimalByIdsType;
+    filterByField: string;
+    filterSortBy?: DatatableSortBy;
+    placeholder?: string | undefined;
+    prefetch?: 'hover' | 'focus' | 'mounted' | false;
+    searchMinChars?: number;
+    itemTitle?: string;
+    itemValue?: string;
+};
+
+declare type __VLS_Props_7 = {
+    name: string;
+    placeholder?: string | undefined;
+    dataCy?: string;
+};
+
+declare type __VLS_Props_8 = {
+    nameFrom: string;
+    nameUntil: string;
+    allowed?: TimeIntervalToolsValue[];
+    placeholder?: string | undefined;
+    dataCy?: string;
+};
+
+declare type __VLS_Props_9 = {
+    name: string;
+    items: ValueObjectOption<string | number>[];
+};
+
+declare type __VLS_PublicProps = {
+    'datatableHiddenColumns'?: string[] | undefined;
+    'showDetail'?: boolean;
+} & __VLS_Props;
+
+declare type __VLS_PublicProps_2 = {
+    'datatableHiddenColumns'?: string[] | undefined;
+} & __VLS_Props_2;
+
+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, (_: {
+        itemConfig: FilterField;
+    }) => any>> & {
+        top?(_: {}): any;
+        bookmarks?(_: {}): any;
+        search?(_: {}): any;
+        buttons?(_: {}): any;
+        detail?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_2(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<string, (_: {
+        itemConfig: FilterField;
+    }) => any>> & {
+        bookmarks?(_: {}): any;
+        detail?(_: {}): any;
+        buttons?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_3(): {
+    attrs: Partial<{}>;
+    slots: {
+        title?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;
+
+declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_2<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_3<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+export declare const ADatatableOrdering: DefineComponent<__VLS_PublicProps_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: number) => any;
+} & {
+sortByChange: (data: DatatableOrderingOption) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps_3> & Readonly<{
+"onUpdate:modelValue"?: ((value: number) => any) | undefined;
+onSortByChange?: ((data: DatatableOrderingOption) => any) | undefined;
+}>, {
+variant: "id" | "createdAt" | "most-relevant";
+customOptions: DatatableOrderingOptions;
+paginationUpdateCustomCb: (option: DatatableOrderingOption, pagination: Ref<Pagination>) => void;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare const ADatatablePagination: DefineComponent<__VLS_Props_11, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+change: () => any;
+}, string, PublicProps, Readonly<__VLS_Props_11> & Readonly<{
+onChange?: (() => any) | undefined;
+}>, {
+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<{
+onChange?: (() => any) | undefined;
+}>, {
+dataCy: string;
+allT: string;
+trueT: string;
+falseT: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare const AFilterDatetimePicker: DefineComponent<__VLS_Props_4, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+change: () => any;
+}, string, PublicProps, Readonly<__VLS_Props_4> & Readonly<{
+onChange?: (() => any) | undefined;
+}>, {
+dataCy: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare const AFilterInteger: DefineComponent<__VLS_Props_5, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+change: () => any;
+}, string, PublicProps, Readonly<__VLS_Props_5> & Readonly<{
+onChange?: (() => any) | undefined;
+}>, {
+placeholder: string;
+dataCy: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare const AFilterRemoteAutocomplete: <T extends string | number>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onChange?: (() => any) | undefined;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onChange"> & {
+        name: string;
+        fetchItems: (pagination: Ref<Pagination>, filterData: FilterData, filterConfig: FilterConfig) => Promise<ValueObjectOption<T>[]>;
+        fetchItemsByIds: (ids: T[]) => Promise<ValueObjectOption<T>[]>;
+        filterByField: string;
+        filterSortBy?: DatatableSortBy;
+        prefetch?: "hover" | "focus" | "mounted" | false;
+        minSearchChars?: number;
+        minSearchText?: string | undefined;
+        placeholder?: string | undefined;
+    } & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<    {}>): void;
+    attrs: any;
+    slots: {};
+    emit: (e: "change") => void;
+}>) => VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+
+export declare const AFilterRemoteAutocompleteWithMinimal: DefineComponent<__VLS_Props_6, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+change: () => any;
+}, string, PublicProps, Readonly<__VLS_Props_6> & Readonly<{
+onChange?: (() => any) | undefined;
+}>, {
+placeholder: string;
+itemTitle: string;
+itemValue: string;
+filterSortBy: {
+key: string;
+order: SortOrderType;
+} | null;
+prefetch: "hover" | "focus" | "mounted" | false;
+searchMinChars: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare const AFilterString: DefineComponent<__VLS_Props_7, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+change: () => any;
+}, string, PublicProps, Readonly<__VLS_Props_7> & Readonly<{
+onChange?: (() => any) | undefined;
+}>, {
+placeholder: string;
+dataCy: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare const AFilterTimeInterval: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;
+
+export declare const AFilterValueObjectOptionsSelect: DefineComponent<__VLS_Props_9, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+change: () => any;
+}, string, PublicProps, Readonly<__VLS_Props_9> & Readonly<{
+onChange?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare const AFilterWrapper: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+export declare const AFilterWrapperSubjectSelect: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;
+
+export declare const AFormRemoteAutocomplete: <T extends string | number>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_2<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal_2<Pick<Partial<{}> & Omit<{
+        readonly onBlur?: ((data: T | T[] | null | undefined) => any) | undefined;
+        readonly onFocus?: ((data: T | T[] | null | undefined) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: T | T[] | null | undefined) => any) | undefined;
+        readonly "onUpdate:selected"?: ((value: ValueObjectOption<T> | ValueObjectOption<T>[] | null) => any) | undefined;
+        readonly onSearchChange?: ((data: string) => any) | undefined;
+        readonly onSearchChangeDebounced?: ((data: string) => any) | undefined;
+        readonly "onClick:chipClose"?: ((data: ValueObjectOption<T>) => any) | undefined;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onUpdate:modelValue" | "onFocus" | "onBlur" | "onUpdate:selected" | "onSearchChange" | "onSearchChangeDebounced" | "onClick:chipClose"> & ({
+        modelValue: T | T[] | null | undefined;
+        selected?: ValueObjectOption<T> | ValueObjectOption<T>[] | null;
+    } & {
+        label?: string | undefined;
+        required?: boolean | undefined;
+        multiple?: boolean;
+        clearable?: boolean;
+        v?: any;
+        errorMessage?: string;
+        hideDetails?: boolean;
+        hideLabel?: boolean;
+        fetchItems: (pagination: Ref<Pagination>, filterData: FilterData, filterConfig: FilterConfig) => Promise<ValueObjectOption<T>[]>;
+        fetchItemsByIds: (ids: T[]) => Promise<ValueObjectOption<T>[]>;
+        filterByField: string;
+        filterSortBy?: DatatableSortBy;
+        loading?: boolean;
+        collab?: CollabComponentConfig;
+        disabled?: boolean | undefined;
+        readonly?: boolean;
+        chips?: boolean;
+        closableChips?: boolean;
+        disableAutoSingleSelect?: boolean;
+        prefetch?: "hover" | "focus" | "mounted" | false;
+        minSearchChars?: number;
+        minSearchText?: string | undefined;
+    }) & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<    {
+    tryLoadModelValue: (tryLoadValue: T | T[] | null | undefined, prefetch?: boolean) => Promise<boolean | undefined>;
+    }>): void;
+    attrs: any;
+    slots: {
+        locked?(_: {
+            userId: number;
+        }): any;
+        append?(_: {}): any;
+    };
+    emit: {
+        (e: "searchChange", data: string): void;
+        (e: "searchChangeDebounced", data: string): void;
+        (e: "blur", data: T | T[] | null | undefined): void;
+        (e: "focus", data: T | T[] | null | undefined): void;
+        (e: "click:chipClose", data: ValueObjectOption<T>): void;
+    } & (((evt: "update:modelValue", value: T | T[] | null | undefined) => void) & ((evt: "update:selected", value: ValueObjectOption<T> | ValueObjectOption<T>[] | null) => void));
+}>) => VNode & {
+    __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;
+    modifiedBy: IntegerIdNullable;
+}
+
+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;
+        readonly onOnConfirm?: ((data: TItem[]) => any) | undefined;
+        readonly onOnOpen?: (() => any) | undefined;
+        readonly "onUpdate:pagination"?: ((data: Pagination) => any) | undefined;
+        readonly onOnPageChange?: (() => any) | undefined;
+        readonly onOnFetchNextPage?: (() => any) | undefined;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onUpdate:modelValue" | "onOnConfirm" | "onOnOpen" | "onUpdate:pagination" | "onOnPageChange" | "onOnFetchNextPage"> & {
+        selectedItems: Array<TItem>;
+        pagination: Pagination;
+        loading?: boolean;
+        minCount?: number;
+        maxCount?: number;
+        modelValue?: boolean | undefined;
+        dialogTitleT?: string;
+        paginationMode?: "standard" | "more";
+        autoOpen?: boolean;
+    } & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<    {
+    open: () => void;
+    closeSidebarOnMobile: () => void;
+    }>): void;
+    attrs: any;
+    slots: {
+        activator?(_: {
+            props: {
+                onClick: () => void;
+            };
+        }): any;
+        title?(_: {}): any;
+        'second-bar'?(_: {}): any;
+        'second-bar-left'?(_: {}): any;
+        'second-bar-right'?(_: {}): any;
+        filter?(_: {}): any;
+        content?(_: {}): any;
+        'button-confirm-title'?(_: {}): any;
+        'button-confirm-title'?(_: {}): any;
+    };
+    emit: {
+        (e: "update:modelValue", data: boolean): void;
+        (e: "update:pagination", data: Pagination): void;
+        (e: "onOpen"): void;
+        (e: "onPageChange"): void;
+        (e: "onConfirm", data: Array<TItem>): void;
+        (e: "onFetchNextPage"): void;
+    };
+}>) => VNode & {
+    __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 {
+    id?: IntegerIdNullable;
+    email: string;
+    person: {
+        firstName: string;
+        lastName: string;
+        fullName: string;
+    };
+    avatar: {
+        color: string;
+        text: string;
+    };
+}
+
+declare type CachedItem<T extends object> = T & {
+    _loaded: boolean;
+};
+
+declare type CollabCachedUsersMap = Map<IntegerId, CachedItem<AnzuUserMinimal>>;
+
+declare type CollabComponentConfig = undefined | {
+    room: CollabRoom;
+    field: CollabFieldName;
+    cachedUsers: CollabCachedUsersMap;
+};
+
+declare type CollabFieldName = string;
+
+declare type CollabRoom = string;
+
+declare type ColumnConfig = {
+    key: string;
+    title?: string;
+    sortable?: boolean;
+    fixed?: boolean;
+    maxWidth?: number;
+};
+
+export declare function createDatatableColumnsConfig(config: ColumnConfig[], columnsHidden: Ref<Array<string>>, system: string, subject: string, moreOptions?: Partial<DatatableColumnsConfigMoreOptions>): {
+    columnsAll: {
+        key: string;
+        title?: string;
+        sortable: boolean;
+        fixed: boolean;
+        maxWidth?: number;
+    }[];
+    columnsVisible: ComputedRef<any>;
+    columnsHidden: Ref<string[], string[]>;
+};
+
+declare interface CreatedByAware {
+    createdBy: IntegerIdNullable;
+}
+
+export declare function createFilter<F extends readonly MakeFilterOption<string>[]>(filterFields: F, store: FilterData<F>, options?: Partial<GeneralFilterOptions>): {
+    filterConfig: FilterConfig<F>;
+    filterData: FilterData<F>;
+};
+
+export declare function createFilterStore<F extends readonly MakeFilterOption<string>[]>(filterFields: F): FilterData<F>;
+
+declare interface DatatableColumnsConfigMoreOptions {
+    storeColumnsLocalStorage: string | boolean;
+    disableActions: boolean;
+    customI18n: any;
+    showExpand: boolean;
+}
+
+declare type DatatableOrderingOption = {
+    id: number;
+    titleT: string;
+    sortBy?: DatatableSortBy;
+    customData?: any;
+};
+
+declare type DatatableOrderingOptions = Array<DatatableOrderingOption>;
+
+export declare const DatatablePaginationKey: InjectionKey<Ref<Pagination>>;
+
+declare type DatatableSortBy = {
+    key: string;
+    order: SortOrderType;
+} | null | undefined;
+
+/**
+ * Datetime in RFC 3339 format as string.
+ */
+declare type DatetimeUTC = string;
+
+/**
+ * Datetime in RFC 3339 format as string + null.
+ */
+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;
+    object?: T;
+};
+
+declare type FetchByIdsParams = {
+    urlTemplate?: string;
+    urlParams?: UrlParams;
+};
+
+declare type FetchItemsMinimalByIdsType = ((ids: IntegerId[]) => Promise<any[]>) | ((ids: DocId[]) => Promise<any[]>);
+
+declare type FetchItemsMinimalType = (pagination: Ref<Pagination>, filterData: FilterData, filterConfig: FilterConfig) => Promise<any[]>;
+
+declare type FetchListBatchParams = {
+    urlTemplate?: string;
+    urlParams?: UrlParams;
+    sortBy?: string;
+    sortDesc?: boolean;
+    batchSize?: number;
+    forceElastic?: boolean;
+};
+
+declare type FetchListParams = {
+    urlTemplate?: string;
+    urlParams?: UrlParams;
+    forceElastic?: boolean;
+};
+
+declare interface FilerRenderOptions {
+    skip: boolean;
+    xs: number | undefined;
+    sm: number | undefined;
+    md: number | undefined;
+    lg: number | undefined;
+    xl: number | undefined;
+}
+
+export declare type FilterConfig<F extends readonly MakeFilterOption<string>[] = readonly MakeFilterOption<string>[]> = {
+    general: GeneralFilterOptions;
+    touched: boolean;
+    fields: {
+        [P in F[number]['name']]: FilterField;
+    };
+};
+
+export declare const FilterConfigKey: InjectionKey<FilterConfig>;
+
+export declare type FilterData<F extends readonly MakeFilterOption<string>[] = readonly MakeFilterOption<string>[]> = {
+    [P in F[number]['name']]: AllowedFilterValues;
+};
+
+export declare const FilterDataKey: InjectionKey<FilterData>;
+
+declare interface FilterField {
+    name: string;
+    type: FilterType;
+    variant: FilterVariant;
+    titleT?: string;
+    default: AllowedFilterValues;
+    apiName: string;
+    clearable: boolean;
+    mandatory: boolean;
+    multiple: boolean;
+    advanced: boolean;
+    exclude: boolean;
+    related: string | undefined;
+    render: FilerRenderOptions;
+}
+
+declare interface FilterHelpersMoreOptions {
+    storeFiltersLocalStorage: string | boolean;
+    populateUrlParams: boolean;
+}
+
+export declare const FilterInnerConfigKey: InjectionKey<FilterConfig>;
+
+export declare const FilterInnerDataKey: InjectionKey<FilterData>;
+
+export declare type FilterStore<T extends readonly {
+    name: string;
+}[]> = {
+    [K in T[number]['name']]: AllowedFilterValues;
+};
+
+declare type FilterStoreIdentifier = {
+    system: string;
+    subject: string;
+};
+
+declare type FilterType = 'boolean' | 'datetime' | 'integer' | 'string' | 'custom' | 'timeInterval';
+
+declare type FilterVariant = 'search' | 'lt' | 'in' | 'notIn' | 'endsWith' | 'startsWith' | 'memberOf' | 'neq' | 'gte' | 'gt' | 'eq' | 'lte' | 'custom';
+
+declare type FilterVariant_2 = 'search' | 'lt' | 'in' | 'notIn' | 'endsWith' | 'startsWith' | 'memberOf' | 'contains' | 'neq' | 'gte' | 'gt' | 'eq' | 'lte' | 'custom';
+
+declare interface GeneralFilterOptions {
+    system?: string;
+    subject?: string;
+    elastic?: boolean;
+    simpleFilters?: boolean;
+}
+
+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.
+ */
+declare type IntegerId = number;
+
+/**
+ * Integer ID + null.
+ */
+declare type IntegerIdNullable = number | null;
+
+declare const JOB_RESOURCE_USER_DATA_DELETE = "jobUserDataDelete";
+
+declare interface JobBase<T extends JobBaseResource = JobBaseResource> extends AnzuUserAndTimeTrackingAware {
+    readonly id: IntegerId;
+    scheduledAt: DatetimeUTC;
+    priority: number;
+    readonly status: JobStatusType;
+    readonly startedAt: DatetimeUTCNullable;
+    readonly finishedAt: DatetimeUTCNullable;
+    readonly lastBatchProcessedRecord: string;
+    readonly batchProcessedIterationCount: number;
+    readonly result: string;
+    _resourceName: T;
+    readonly _system: string;
+}
+
+declare type JobBaseResource = typeof JOB_RESOURCE_USER_DATA_DELETE | `job${string}`;
+
+declare const JobStatus: {
+    readonly Waiting: "waiting";
+    readonly Processing: "processing";
+    readonly AwaitingBatchProcess: "awaiting_batch_process";
+    readonly Done: "done";
+    readonly Error: "error";
+};
+
+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;
+    type?: FilterType;
+    variant?: FilterVariant;
+    titleT?: string;
+    apiName?: string;
+    clearable?: boolean;
+    mandatory?: boolean;
+    advanced?: boolean;
+    exclude?: boolean;
+    related?: string | undefined;
+    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;
+    rowsPerPage: number;
+    rowsNumber: number;
+    hasNextPage: null | boolean;
+    currentViewCount: number;
+    totalCount: number;
+}
+
+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";
+};
+
+declare type SortOrderType = (typeof SortOrder)[keyof typeof SortOrder];
+
+export declare const TimeIntervalSpecialOptions: {
+    readonly CurrentMonth: "cm";
+    readonly LastMonth: "lm";
+    readonly Last3Months: "l3m";
+    readonly Custom: "custom";
+};
+
+declare type TimeIntervalSpecialOptionsType = (typeof TimeIntervalSpecialOptions)[keyof 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;
+};
+
+declare type UseApiAnyRequestReturnType<R, T = R> = {
+    executeRequest: (params?: ExecuteRequestParams<T>) => Promise<R>;
+    abortRequest: () => void;
+};
+
+export declare const useApiFetchByIds: <R>(params: UseApiFetchByIdsParams) => UseApiFetchByIdsReturnType<R>;
+
+declare type UseApiFetchByIdsParams = {
+    client: AxiosClientFn;
+    system: string;
+    entity: string;
+    urlTemplate?: string;
+    urlParams?: UrlParams;
+    options?: AxiosRequestConfig;
+    isSearchApi?: boolean;
+    field?: string;
+    silentConsoleError?: boolean;
+};
+
+declare type UseApiFetchByIdsReturnType<R> = {
+    executeFetch: (ids: DocId[] | IntegerId[], params?: FetchByIdsParams) => Promise<R>;
+    abortFetch: () => void;
+};
+
+export declare const useApiFetchList: <R>(params: UseApiFetchListParams) => UseApiFetchListReturnType<R>;
+
+export declare const useApiFetchListBatch: <R>(params: UseApiFetchListBatchParams) => UseApiFetchListBatchReturnType<R>;
+
+declare type UseApiFetchListBatchParams = {
+    client: AxiosClientFn;
+    system: string;
+    entity: string;
+    urlTemplate?: string;
+    urlParams?: UrlParams;
+    options?: AxiosRequestConfig;
+    silentConsoleError?: boolean;
+};
+
+declare type UseApiFetchListBatchReturnType<R> = {
+    executeFetch: (filterData: FilterData<any>, filterConfig: FilterConfig<any>, params?: FetchListBatchParams) => Promise<R>;
+    abortFetch: () => void;
+};
+
+declare type UseApiFetchListParams = {
+    client: AxiosClientFn;
+    system: string;
+    entity: string;
+    urlTemplate?: string;
+    urlParams?: UrlParams;
+    options?: AxiosRequestConfig;
+    silentConsoleError?: boolean;
+};
+
+declare type UseApiFetchListReturnType<R> = {
+    executeFetch: (pagination: Ref<Pagination>, filterData: FilterData<any>, filterConfig: FilterConfig<any>, params?: FetchListParams) => Promise<R>;
+    abortFetch: () => void;
+};
+
+/**
+ * Docs: /doc/Admin-Cms-Doc/Filters.md
+ */
+export declare function useApiQueryBuilder(): {
+    resolveTimeIntervalFilter: (fromName: string, untilName: string, filterData: FilterData<any>, filterConfig: FilterConfig<any>, mandatory: boolean, exclude: boolean) => null | {
+        from: DatetimeUTCNullable;
+        until: DatetimeUTCNullable;
+    };
+    querySetLimit: (value: number) => void;
+    querySetOffset: (page: number, limit: number) => void;
+    querySetOrder: (field: string | null, desc: boolean) => void;
+    queryAddFilter: (filterVariant: FilterVariant_2, field: string, value: string | number | boolean) => void;
+    querySetFilters: (filterData: FilterData<any>, filterConfig: FilterConfig<any>) => void;
+    queryAdd: (key: string, value: any) => void;
+    queryBuild: () => string;
+    q: Ref<string[], string[]>;
+};
+
+export declare const useApiRequest: <R, T = R>(params: UseApiRequestParams) => UseApiAnyRequestReturnType<R, T>;
+
+declare type UseApiRequestParams = {
+    client: AxiosClientFn;
+    method: Method;
+    system: string;
+    entity: string;
+    urlTemplate?: string;
+    urlParams?: UrlParams;
+    options?: AxiosRequestConfig;
+    silentConsoleError?: boolean;
+};
+
+export declare function useFilterHelpers<F extends readonly MakeFilterOption<string>[] = readonly MakeFilterOption<string>[]>(filterData: FilterData<F>, filterConfig: FilterConfig<F>, moreOptions?: Partial<FilterHelpersMoreOptions>): {
+    loadStoredFilters: (pagination: Ref<Pagination>, callback?: AnyFn) => boolean;
+    resetFilter: (pagination: Ref<Pagination>, callback?: AnyFn) => void;
+    submitFilter: (pagination: Ref<Pagination>, callback?: AnyFn) => void;
+    serializeFilters: (data: Record<string, AllowedFilterValues>, pagination: Ref<Pagination>, includeSort: boolean) => string;
+    deserializeFilters: (hash: string) => {
+        filters: Record<string, AllowedFilterValues>;
+        sortBy: DatatableSortBy;
+    } | null;
+};
+
+export declare function useJobApi<JobType extends JobBase = JobBase>(client: () => AxiosInstance, system: string): {
+    useFetchJobList: () => UseApiFetchListReturnType<JobType[]>;
+    fetchJob: (id: number) => Promise<JobType>;
+    createJob: (data: JobType) => Promise<JobType>;
+    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 {
+    pagination: Ref<Pagination>;
+    setSortBy: (sortBy: DatatableSortBy) => void;
+    setPage: (page: number) => void;
+    incrementPage: () => number;
+}
+
+export declare interface UserAdminConfig<TData = UserAdminConfigDataFilterBookmark | UserAdminConfigDataPinnedWidgets> extends AnzuUserAndTimeTrackingAware, SortableItemDataAware {
+    id: IntegerId;
+    user: IntegerId;
+    configType: UserAdminConfigTypeType;
+    layoutType: UserAdminConfigLayoutTypeType;
+    systemResource: string;
+    customName: string;
+    defaultConfig: boolean;
+    data: TData;
+    position: number;
+    _resourceName: 'userAdminConfig';
+    _system: string;
+}
+
+export declare interface UserAdminConfigDataFilterBookmark {
+    filter: string;
+    datatableHiddenColumns?: string[];
+    sortBy?: DatatableSortBy;
+}
+
+export declare type UserAdminConfigDataPinnedWidgets<TVariant extends string = string> = Array<{
+    variant: TVariant;
+    position: number;
+}>;
+
+export declare const UserAdminConfigLayoutType: {
+    readonly Desktop: "desktop";
+    readonly Mobile: "mobile";
+};
+
+export declare const UserAdminConfigLayoutTypeDefault: "desktop";
+
+export declare type UserAdminConfigLayoutTypeType = (typeof UserAdminConfigLayoutType)[keyof typeof UserAdminConfigLayoutType];
+
+export declare const UserAdminConfigType: {
+    readonly PinnedWidgets: "pinnedWidgets";
+    readonly FilterBookmark: "filterBookmark";
+};
+
+export declare const UserAdminConfigTypeDefault: "pinnedWidgets";
+
+export declare type UserAdminConfigTypeType = (typeof UserAdminConfigType)[keyof typeof UserAdminConfigType];
+
+export declare function useSubjectSelect<TItem>(datatableConfig: any, datatableHiddenColumns: any, system: string, subject: string, executeFetch: (pagination: Ref<Pagination>, filterData: FilterData<any>, filterConfig: FilterConfig<any>, params?: FetchListParams) => Promise<TItem[]>, filterData: FilterData<any>, filterConfig: FilterConfig<any>, filterSortBy?: DatatableSortBy | null, fetchParams?: FetchListParams | undefined, enableActions?: boolean): {
+    items: Ref<TItem[], TItem[]>;
+    selected: Ref<TItem[], TItem[]>;
+    pagination: Ref<Pagination, Pagination>;
+    columnsVisible: ComputedRef<any>;
+    columnsHidden: Ref<string[], string[]>;
+    columnsAll: {
+        key: string;
+        title?: string;
+        sortable: boolean;
+        fixed: boolean;
+        maxWidth?: number;
+    }[];
+    filterTouched: Ref<boolean, boolean>;
+    loading: Ref<boolean, boolean>;
+    onRowClick: (event: Event) => void;
+    onFetchNextPage: () => Promise<void>;
+    onOpen: () => void;
+    sortByChange: (option: DatatableOrderingOption) => void;
+    getList: UseDebounceFnReturn<() => Promise<void>>;
+    resetFilter: () => void;
+    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>>>;
+    createUserAdminConfig: (data: UserAdminConfig) => Promise<UserAdminConfig<UserAdminConfigDataFilterBookmark | UserAdminConfigDataPinnedWidgets<string>>>;
+    updateUserAdminConfig: (id: IntegerId, data: UserAdminConfig) => Promise<UserAdminConfig<UserAdminConfigDataFilterBookmark | UserAdminConfigDataPinnedWidgets<string>>>;
+    deleteUserAdminConfig: (id: IntegerId) => Promise<unknown>;
+    updateUserAdminConfigPositions: (ids: IntegerId[]) => Promise<{
+        userAdminConfigs: IntegerId[];
+    }>;
+};
+
+export declare function useUserAdminConfigFactory(): {
+    createDefaultUserAdminConfig: (system: string) => UserAdminConfig;
+};
+
+declare interface ValueObjectOption<T> {
+    value: T;
+    title: string;
+    color?: string;
+    active?: false;
+    subtitle?: string;
+}
+
+export { }