@retailcrm/embed-ui-v1-components 0.9.12 → 0.9.14

package/dist/remote.d.ts

@@ -25,6 +25,8 @@ import { PublicProps } from 'vue';
 import { Ref } from 'vue';
 import { RemoteCallable } from '@remote-ui/rpc';
 import { RemoteRoot } from '@omnicajs/vue-remote/remote';
+import { RendererElement } from 'vue';
+import { RendererNode } from 'vue';
 import { SchemaOf } from '@omnicajs/vue-remote/remote';
 import { SchemaType } from '@omnicajs/vue-remote/remote';
 import { SchemaType as SchemaType_2 } from '@omnicajs/vue-remote/dist/remote';
@@ -36,6 +38,7 @@ import { ShallowUnwrapRef } from 'vue';
 import { Side } from '@floating-ui/dom';
 import { Slot } from 'vue';
 import { Strategy } from '@floating-ui/dom';
+import { VNode } from 'vue';
 import { VNodeProps } from 'vue';
 import { WatchOptions } from 'vue';
 import { WatchStopHandle } from 'vue';
@@ -731,7 +734,12 @@ declare type __VLS_WithTemplateSlots_4<T, S> = T & {
     };
 };
 declare type Adaptation = 'flip' | 'shift';
-declare enum ALIGN {
+export declare enum ALIGN {
+    LEFT = "left",
+    CENTER = "center",
+    RIGHT = "right"
+}
+declare enum ALIGN_2 {
     LEFT = "left",
     RIGHT = "right"
 }
@@ -758,6 +766,9 @@ declare enum APPEARANCE_4 {
     POPUP = "popup",
     HINT = "hint"
 }
+export declare const asRowAttrs: <T>(value: RowAttrsGetter<T>) => RowAttrsGetter<T>;
+export declare const asRowClass: <T>(value: RowClassGetter<T>) => RowClassGetter<T>;
+export declare const byRowKey: <T, K extends keyof T>(key: K) => RowKeyGetter<T>;
 declare enum CLOSE_METHOD {
     CLICK_CROSS = "Cross",
     CLICK_OUTSIDE = "Outside",
@@ -783,18 +794,56 @@ declare enum COLOR_2 {
     RED = "red",
     YELLOW = "yellow"
 }
+export declare type Column<T> = {
+    id: string;
+    label: string;
+    width?: Numeric;
+    minWidth?: Numeric;
+    maxWidth?: Numeric;
+    align: ALIGN | `${ALIGN}`;
+    valign: VALIGN | `${VALIGN}`;
+    trim: boolean;
+    getColspan: (row: T, index: number) => number | undefined;
+    getRowspan: (row: T, index: number) => number | undefined;
+};
 export declare const createEndpointRoot: (channel: Channel) => Promise<RemoteRoot<SchemaOf<string>>>;
+export declare type CssClass = string | Record<string, boolean> | Array<string | Record<string, boolean>>;
+export declare type DataForCell<T> = {
+    row: T;
+    index: number;
+    key: RowKey;
+    expanded: boolean;
+    toggle: () => void;
+    column: Column<T>;
+};
+export declare type DataForFooter<T, GroupData> = {
+    columnsCount: number;
+    rowsCount: number;
+    groupsCount: number;
+    groups: readonly Group<T, GroupData>[];
+};
+export declare type DataForGroupHead<T, GroupData> = {
+    group: Group<T, GroupData>;
+    index: number;
+};
+export declare type DataForLabel<T> = {
+    column: Column<T>;
+};
 declare type DateFormatter = (date: Date, omitYear?: boolean) => string;
 declare type Delay = {
     show?: number;
     hide?: number;
 };
 declare type Dimensions = `${number}x${number}` | `${number}x-` | `-x${number}`;
-declare enum DIRECTION {
+export declare enum DIRECTION {
+    ASC = "asc",
+    DESC = "desc"
+}
+declare enum DIRECTION_2 {
     LEFT = "left",
     RIGHT = "right"
 }
-declare enum DIRECTION_2 {
+declare enum DIRECTION_3 {
     HORIZONTAL = "horizontal",
     VERTICAL = "vertical"
 }
@@ -807,6 +856,12 @@ declare type FloatingOptions = {
 export declare const formatDate: (date: Date | string, locale?: Locale | undefined) => string;
 export declare const formatDateTime: (date: Date | string, locale?: Locale | undefined) => string;
 export declare const formatTime: (date: Date | string) => string;
+export declare type Group<T, GroupData> = {
+    key: RowKey;
+    data: GroupData;
+    rows: readonly T[];
+};
+export declare type GroupBy<T, GroupData> = (rows: readonly T[]) => Group<T, GroupData>[];
 export declare const ImageWorkersKey: InjectionKey<Ref<string[]>>;
 declare enum INPUTMODE {
     DECIMAL = "decimal",
@@ -846,6 +901,25 @@ declare type QuickOption = {
     value: Exclude<QuickDate, null>;
 };
 declare type RemoteProperties<T> = HTMLAttributes & T & Record<string, never>;
+export declare type RowAttrs = Record<string, string | number | boolean | undefined> & {
+    class?: CssClass;
+};
+export declare type RowAttrsGetter<T> = (row: T, index: number) => RowAttrs;
+export declare type RowClassGetter<T> = (row: T, index: number) => CssClass;
+export declare type RowClickPayload<T> = {
+    row: T;
+    index: number;
+    key: RowKey;
+    expanded: boolean;
+    toggle: () => void;
+};
+export declare type RowKey = string | number;
+export declare type RowKeyGetter<T> = (row: T, index: number) => RowKey;
+export declare type RowRendererArgs<T> = {
+    row: T;
+    index: number;
+    key: RowKey;
+};
 declare enum SCROLLING {
     NORMAL = "normal",
     NATIVE = "native",
@@ -1870,7 +1944,7 @@ export declare const UiError: {
 });
 declare type UiErrorProperties = {
     message: string;
-    align?: ALIGN | `${ALIGN}`;
+    align?: ALIGN_2 | `${ALIGN_2}`;
     ellipsis?: boolean;
 };
 export declare const UiErrorType: SchemaType<"UiError", RemoteProperties<UiErrorProperties>, Record<string, never>>;
@@ -2246,7 +2320,7 @@ declare type UiModalSidebarProperties = {
     id?: string;
     opened?: boolean;
     closable?: boolean;
-    direction?: DIRECTION | `${DIRECTION}`;
+    direction?: DIRECTION_2 | `${DIRECTION_2}`;
     disposeTimeout?: number | string | null;
     fixed?: boolean;
     scrolling?: SCROLLING | `${SCROLLING}`;
@@ -2485,7 +2559,7 @@ declare type UiNumberStepperProperties = {
     disabled?: boolean;
     readonly?: boolean;
     required?: boolean;
-    direction?: DIRECTION_2 | `${DIRECTION_2}`;
+    direction?: DIRECTION_3 | `${DIRECTION_3}`;
     size?: SIZE_4 | `${SIZE_4}`;
     outlined?: boolean;
     textboxOptions?: Partial<Omit<UiTextboxProperties, 'id' | 'value' | 'type' | 'min' | 'max' | 'step' | 'decimals' | 'clearable' | 'disabled' | 'readonly' | 'required' | 'size' | 'outlined' | 'autofit' | 'inputAttributes'>>;
@@ -2924,6 +2998,524 @@ declare type UiSwitchProperties = {
     disabled?: boolean;
 };
 export declare const UiSwitchType: SchemaType<"UiSwitch", RemoteProperties<UiSwitchProperties>, RemoteCallable<UiSwitchMethods>>;
+export declare const UiTable: DefineComponent<ExtractPropTypes<{
+    rows: {
+        type: PropType<readonly unknown[]>;
+        default: () => never[];
+    };
+    rowKey: {
+        type: PropType<string | number | RowKeyGetter<unknown>>;
+        default: undefined;
+    };
+    headless: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    bordered: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fixed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    rowClass: {
+        type: PropType<CssClass | RowClassGetter<unknown>>;
+        default: undefined;
+    };
+    rowAttrs: {
+        type: PropType<RowAttrsGetter<unknown>>;
+        default: undefined;
+    };
+    groupBy: {
+        type: PropType<GroupBy<unknown, unknown>>;
+        default: undefined;
+    };
+    groupHeadClass: {
+        type: PropType<CssClass>;
+        default: undefined;
+    };
+    groupBodyClass: {
+        type: PropType<CssClass>;
+        default: undefined;
+    };
+}>, () => VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    'row:click': (payload: RowClickPayload<unknown>, event: SerializedEvent) => true;
+}, string, PublicProps, Readonly<ExtractPropTypes<{
+    rows: {
+        type: PropType<readonly unknown[]>;
+        default: () => never[];
+    };
+    rowKey: {
+        type: PropType<string | number | RowKeyGetter<unknown>>;
+        default: undefined;
+    };
+    headless: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    bordered: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fixed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    rowClass: {
+        type: PropType<CssClass | RowClassGetter<unknown>>;
+        default: undefined;
+    };
+    rowAttrs: {
+        type: PropType<RowAttrsGetter<unknown>>;
+        default: undefined;
+    };
+    groupBy: {
+        type: PropType<GroupBy<unknown, unknown>>;
+        default: undefined;
+    };
+    groupHeadClass: {
+        type: PropType<CssClass>;
+        default: undefined;
+    };
+    groupBodyClass: {
+        type: PropType<CssClass>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onRow:click"?: ((payload: RowClickPayload<unknown>, event: SerializedEvent) => any) | undefined;
+}>, {
+    fixed: boolean;
+    bordered: boolean;
+    rows: readonly unknown[];
+    rowKey: string | number | RowKeyGetter<unknown>;
+    headless: boolean;
+    rowClass: CssClass | RowClassGetter<unknown>;
+    rowAttrs: RowAttrsGetter<unknown>;
+    groupBy: GroupBy<unknown, unknown>;
+    groupHeadClass: CssClass;
+    groupBodyClass: CssClass;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export declare const UiTableBodyCell: {
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<RemoteProperties<UiTableBodyCellProperties>>>, {
+        [x: string]: unknown;
+    }, {
+        [x: string]: never;
+    }, {
+        [x: string]: never;
+    }, MethodOptions, {
+        [x: string]: never;
+    }, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: ComputedOptions;
+        M: MethodOptions;
+        Defaults: {};
+    } & {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<ExtractPropTypes<RemoteProperties<UiTableBodyCellProperties>>>, {
+        [x: string]: unknown;
+    }, {
+        [x: string]: never;
+    }, ComputedOptions & {
+        [x: string]: never;
+    }, MethodOptions, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly<ExtractPropTypes<RemoteProperties<UiTableBodyCellProperties>>>, {
+    [x: string]: unknown;
+}, {
+    [x: string]: never;
+}, {
+    [x: string]: never;
+}, MethodOptions, {
+    [x: string]: never;
+}, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        [x: string]: never;
+    } & {
+        default?: (...args: never[]) => unknown;
+    };
+});
+export declare type UiTableBodyCellProperties = {
+    align?: ALIGN | `${ALIGN}`;
+    valign?: VALIGN | `${VALIGN}`;
+    colspan?: number;
+    rowspan?: number;
+    trim?: boolean;
+    theme?: UiTableBodyCellTheme;
+};
+export declare type UiTableBodyCellTheme = 'default' | 'group';
+export declare type UiTableColProperties = {
+    width?: Numeric;
+    minWidth?: Numeric;
+    maxWidth?: Numeric;
+};
+export declare const UiTableColumn: DefineComponent<ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    width: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    minWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    maxWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    align: {
+        type: PropType<ALIGN | `${ALIGN}`>;
+        default: ALIGN;
+        validator: (align: string) => boolean;
+    };
+    valign: {
+        type: PropType<VALIGN | `${VALIGN}`>;
+        default: VALIGN;
+        validator: (valign: string) => boolean;
+    };
+    trim: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    colspan: {
+        type: PropType<(row: unknown, index: number) => number | undefined>;
+        default: undefined;
+    };
+    rowspan: {
+        type: PropType<(row: unknown, index: number) => number | undefined>;
+        default: undefined;
+    };
+}>, () => null, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    width: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    minWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    maxWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    align: {
+        type: PropType<ALIGN | `${ALIGN}`>;
+        default: ALIGN;
+        validator: (align: string) => boolean;
+    };
+    valign: {
+        type: PropType<VALIGN | `${VALIGN}`>;
+        default: VALIGN;
+        validator: (valign: string) => boolean;
+    };
+    trim: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    colspan: {
+        type: PropType<(row: unknown, index: number) => number | undefined>;
+        default: undefined;
+    };
+    rowspan: {
+        type: PropType<(row: unknown, index: number) => number | undefined>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    trim: boolean;
+    width: string | number;
+    align: "left" | "right" | "center" | ALIGN;
+    label: string;
+    minWidth: string | number;
+    maxWidth: string | number;
+    valign: "bottom" | "top" | "middle" | VALIGN;
+    colspan: (row: unknown, index: number) => number | undefined;
+    rowspan: (row: unknown, index: number) => number | undefined;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export declare type UiTableColumnProperties<T> = {
+    label?: string;
+    width?: Numeric;
+    minWidth?: Numeric;
+    maxWidth?: Numeric;
+    align?: ALIGN | `${ALIGN}`;
+    valign?: VALIGN | `${VALIGN}`;
+    trim?: boolean;
+    colspan?: (row: T, index: number) => number | undefined;
+    rowspan?: (row: T, index: number) => number | undefined;
+};
+export declare type UiTableColumnSlots<T> = {
+    default?: (props: DataForCell<T>) => unknown;
+    cell?: (props: DataForCell<T>) => unknown;
+    label?: (props: DataForLabel<T>) => unknown;
+};
+export declare type UiTableEmits<T> = {
+    'row:click': [
+        payload: RowClickPayload<T>,
+        event: SerializedEvent
+    ];
+};
+export declare const UiTableFooterButton: {
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<RemoteProperties<UiTableFooterButtonProperties>>>, {
+        [x: string]: unknown;
+    }, {
+        [x: string]: never;
+    }, {
+        [x: string]: never;
+    }, MethodOptions, {
+        click: (event: SerializedEvent) => boolean;
+    }, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: ComputedOptions;
+        M: MethodOptions;
+        Defaults: {};
+    } & {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<ExtractPropTypes<RemoteProperties<UiTableFooterButtonProperties>>>, {
+        [x: string]: unknown;
+    }, {
+        [x: string]: never;
+    }, ComputedOptions & {
+        [x: string]: never;
+    }, MethodOptions, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly<ExtractPropTypes<RemoteProperties<UiTableFooterButtonProperties>>>, {
+    [x: string]: unknown;
+}, {
+    [x: string]: never;
+}, {
+    [x: string]: never;
+}, MethodOptions, {
+    click: (event: SerializedEvent) => boolean;
+}, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        [x: string]: never;
+    } & {
+        default?: (...args: never[]) => unknown;
+    };
+});
+export declare type UiTableFooterButtonProperties = {
+    type?: UiTableFooterButtonType;
+};
+export declare type UiTableFooterButtonType = 'button' | 'submit' | 'reset';
+export declare const UiTableFooterSection: {
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<RemoteProperties<UiTableFooterSectionProperties>>>, {
+        [x: string]: unknown;
+    }, {
+        [x: string]: never;
+    }, {
+        [x: string]: never;
+    }, MethodOptions, {
+        [x: string]: never;
+    }, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: ComputedOptions;
+        M: MethodOptions;
+        Defaults: {};
+    } & {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<ExtractPropTypes<RemoteProperties<UiTableFooterSectionProperties>>>, {
+        [x: string]: unknown;
+    }, {
+        [x: string]: never;
+    }, ComputedOptions & {
+        [x: string]: never;
+    }, MethodOptions, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly<ExtractPropTypes<RemoteProperties<UiTableFooterSectionProperties>>>, {
+    [x: string]: unknown;
+}, {
+    [x: string]: never;
+}, {
+    [x: string]: never;
+}, MethodOptions, {
+    [x: string]: never;
+}, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        [x: string]: never;
+    } & {
+        default?: (...args: never[]) => unknown;
+    };
+});
+export declare type UiTableFooterSectionProperties = Record<string, never>;
+export declare const UiTableHeadCell: {
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<RemoteProperties<UiTableHeadCellProperties>>>, {
+        [x: string]: unknown;
+    }, {
+        [x: string]: never;
+    }, {
+        [x: string]: never;
+    }, MethodOptions, {
+        [x: string]: never;
+    }, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: ComputedOptions;
+        M: MethodOptions;
+        Defaults: {};
+    } & {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<ExtractPropTypes<RemoteProperties<UiTableHeadCellProperties>>>, {
+        [x: string]: unknown;
+    }, {
+        [x: string]: never;
+    }, ComputedOptions & {
+        [x: string]: never;
+    }, MethodOptions, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly<ExtractPropTypes<RemoteProperties<UiTableHeadCellProperties>>>, {
+    [x: string]: unknown;
+}, {
+    [x: string]: never;
+}, {
+    [x: string]: never;
+}, MethodOptions, {
+    [x: string]: never;
+}, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        [x: string]: never;
+    } & {
+        default?: (...args: never[]) => unknown;
+    };
+});
+export declare type UiTableHeadCellProperties = {
+    align?: ALIGN | `${ALIGN}`;
+    trim?: boolean;
+};
+export declare type UiTableMethods<RowKeyValue extends RowKey = RowKey> = {
+    resetExpanded(): void;
+    expand(key: RowKeyValue): void;
+    collapse(key: RowKeyValue): void;
+    toggle(key: RowKeyValue): void;
+};
+export declare type UiTableProperties<T, GroupData = undefined> = {
+    rows: readonly T[];
+    rowKey?: keyof T | RowKeyGetter<T>;
+    headless?: boolean;
+    bordered?: boolean;
+    fixed?: boolean;
+    rowClass?: CssClass | RowClassGetter<T>;
+    rowAttrs?: RowAttrsGetter<T>;
+    groupBy?: GroupBy<T, GroupData>;
+    groupHeadClass?: CssClass;
+    groupBodyClass?: CssClass;
+};
+export declare type UiTableRootProperties = {
+    bordered?: boolean;
+    fixed?: boolean;
+};
+export declare type UiTableRowProperties = {
+    interactive?: boolean;
+    expanded?: boolean;
+};
+export declare type UiTableSectionKind = 'head' | 'body' | 'foot';
+export declare type UiTableSectionProperties = {
+    kind?: UiTableSectionKind;
+};
+export declare type UiTableSlots<T, GroupData = undefined> = {
+    default?: () => unknown;
+    expand?: (props: RowRendererArgs<T>) => unknown;
+    footer?: (props: DataForFooter<T, GroupData>) => unknown;
+    'footer-summary'?: (props: DataForFooter<T, GroupData>) => unknown;
+    'footer-page-size'?: (props: DataForFooter<T, GroupData>) => unknown;
+    'footer-export'?: (props: DataForFooter<T, GroupData>) => unknown;
+    'footer-pagination'?: (props: DataForFooter<T, GroupData>) => unknown;
+    'group-head'?: (props: DataForGroupHead<T, GroupData>) => unknown;
+    empty?: () => unknown;
+};
+export declare const UiTableSorter: {
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<RemoteProperties<UiTableSorterProperties>>>, {
+        [x: string]: unknown;
+    }, {
+        [x: string]: never;
+    }, {
+        [x: string]: never;
+    }, MethodOptions, {
+        click: (event: SerializedEvent) => boolean;
+    }, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: ComputedOptions;
+        M: MethodOptions;
+        Defaults: {};
+    } & {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<ExtractPropTypes<RemoteProperties<UiTableSorterProperties>>>, {
+        [x: string]: unknown;
+    }, {
+        [x: string]: never;
+    }, ComputedOptions & {
+        [x: string]: never;
+    }, MethodOptions, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly<ExtractPropTypes<RemoteProperties<UiTableSorterProperties>>>, {
+    [x: string]: unknown;
+}, {
+    [x: string]: never;
+}, {
+    [x: string]: never;
+}, MethodOptions, {
+    click: (event: SerializedEvent) => boolean;
+}, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        [x: string]: never;
+    } & {
+        default?: (...args: never[]) => unknown;
+    };
+});
+export declare type UiTableSorterProperties = {
+    direction?: DIRECTION | `${DIRECTION}` | null;
+};
 export declare const UiTag: {
     new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<RemoteProperties<UiTagProperties>>>, {
         [x: string]: unknown;
@@ -3476,6 +4068,11 @@ export declare const usePreview: (workers?: Ref<string[]>) => {
     workers: Ref<string[], string[]>;
     preview: (url: string, resize?: Dimensions | undefined, crop?: Dimensions | undefined) => string;
 };
+export declare enum VALIGN {
+    TOP = "top",
+    MIDDLE = "middle",
+    BOTTOM = "bottom"
+}
 declare enum VARIANT {
     PRIMARY = "primary",
     WARNING = "warning",