import type { Description } from '@aeriajs/types';
import type { file } from '@aeriajs/builtins';
import { Result } from '@aeriajs/types';
import { type IndividualActionPayload } from '../composables/use-action.js';
export type User = {
    _id: string;
    name: string;
    roles: string[];
    password?: string;
    picture_file?: typeof file.item & {
        _id: string;
    };
};
export type SuccessfulAuthentication = {
    token: {
        type: 'bearer';
        content: string;
    };
    user: User;
};
export type Credentials = {
    email: string;
    password: string;
};
export declare const user: (context: import("@aeria-ui/state-management").StoreContext, config?: unknown) => import("../state/collection.js").InitialState<import("mongodb").WithId<unknown>> & {
    item: {
        _id: string;
        name: string;
        roles: string[];
        password?: string | undefined;
        picture_file?: {
            type: string;
            name: string;
            link: never;
            immutable: boolean;
            size: number;
            last_modified: Date;
            absolute_path: string;
            relative_path: string;
            download_link: never;
            owner?: {
                _id: {
                    readonly _bsontype: "ObjectId";
                    id: {
                        [x: number]: number;
                        readonly BYTES_PER_ELEMENT: number;
                        readonly buffer: {
                            readonly byteLength: number;
                            slice: (begin?: number, end?: number) => ArrayBuffer;
                            readonly maxByteLength: number;
                            readonly resizable: boolean;
                            resize: (newByteLength?: number) => void;
                            readonly detached: boolean;
                            transfer: (newByteLength?: number) => ArrayBuffer;
                            transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
                            readonly [Symbol.toStringTag]: "ArrayBuffer";
                        } | {
                            readonly byteLength: number;
                            slice: (begin?: number, end?: number) => SharedArrayBuffer;
                            readonly growable: boolean;
                            readonly maxByteLength: number;
                            grow: (newByteLength?: number) => void;
                            readonly [Symbol.toStringTag]: "SharedArrayBuffer";
                        };
                        readonly byteLength: number;
                        readonly byteOffset: number;
                        copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
                        every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
                        fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
                        filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
                        find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
                        findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
                        forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
                        indexOf: (searchElement: number, fromIndex?: number) => number;
                        join: (separator?: string) => string;
                        lastIndexOf: (searchElement: number, fromIndex?: number) => number;
                        readonly length: number;
                        map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
                        reduce: {
                            (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
                            (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
                            <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
                        };
                        reduceRight: {
                            (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
                            (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
                            <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
                        };
                        reverse: () => Uint8Array<ArrayBufferLike>;
                        set: (array: ArrayLike<number>, offset?: number) => void;
                        slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
                        some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
                        sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
                        subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
                        toLocaleString: {
                            (): string;
                            (locales: string | string[], options?: Intl.NumberFormatOptions): string;
                        };
                        toString: () => string;
                        valueOf: () => Uint8Array<ArrayBufferLike>;
                        entries: () => ArrayIterator<[number, number]>;
                        keys: () => ArrayIterator<number>;
                        values: () => ArrayIterator<number>;
                        includes: (searchElement: number, fromIndex?: number) => boolean;
                        at: (index: number) => number | undefined;
                        findLast: {
                            <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
                            (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
                        };
                        findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
                        toReversed: () => Uint8Array<ArrayBuffer>;
                        toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
                        with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
                        [Symbol.iterator]: () => ArrayIterator<number>;
                        readonly [Symbol.toStringTag]: "Uint8Array";
                    };
                    toHexString: () => string;
                    toString: (encoding?: "hex" | "base64") => string;
                    toJSON: () => string;
                    equals: (otherId: string | import("bson").ObjectId | import("bson").ObjectIdLike | undefined | null) => boolean;
                    getTimestamp: () => Date;
                    inspect: (depth?: number, options?: unknown, inspect?: (x: unknown, options?: unknown) => string) => string;
                };
            } | undefined;
            updated_at?: Date | undefined;
            created_at?: Date | undefined;
            _id: import("bson").ObjectId & string;
        } | undefined;
    };
    currentUser: {
        _id: string;
        name: string;
        roles: string[];
        password?: string | undefined;
        picture_file?: {
            type: string;
            name: string;
            link: never;
            immutable: boolean;
            size: number;
            last_modified: Date;
            absolute_path: string;
            relative_path: string;
            download_link: never;
            owner?: {
                _id: {
                    readonly _bsontype: "ObjectId";
                    id: {
                        [x: number]: number;
                        readonly BYTES_PER_ELEMENT: number;
                        readonly buffer: {
                            readonly byteLength: number;
                            slice: (begin?: number, end?: number) => ArrayBuffer;
                            readonly maxByteLength: number;
                            readonly resizable: boolean;
                            resize: (newByteLength?: number) => void;
                            readonly detached: boolean;
                            transfer: (newByteLength?: number) => ArrayBuffer;
                            transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
                            readonly [Symbol.toStringTag]: "ArrayBuffer";
                        } | {
                            readonly byteLength: number;
                            slice: (begin?: number, end?: number) => SharedArrayBuffer;
                            readonly growable: boolean;
                            readonly maxByteLength: number;
                            grow: (newByteLength?: number) => void;
                            readonly [Symbol.toStringTag]: "SharedArrayBuffer";
                        };
                        readonly byteLength: number;
                        readonly byteOffset: number;
                        copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
                        every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
                        fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
                        filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
                        find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
                        findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
                        forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
                        indexOf: (searchElement: number, fromIndex?: number) => number;
                        join: (separator?: string) => string;
                        lastIndexOf: (searchElement: number, fromIndex?: number) => number;
                        readonly length: number;
                        map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
                        reduce: {
                            (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
                            (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
                            <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
                        };
                        reduceRight: {
                            (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
                            (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
                            <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
                        };
                        reverse: () => Uint8Array<ArrayBufferLike>;
                        set: (array: ArrayLike<number>, offset?: number) => void;
                        slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
                        some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
                        sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
                        subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
                        toLocaleString: {
                            (): string;
                            (locales: string | string[], options?: Intl.NumberFormatOptions): string;
                        };
                        toString: () => string;
                        valueOf: () => Uint8Array<ArrayBufferLike>;
                        entries: () => ArrayIterator<[number, number]>;
                        keys: () => ArrayIterator<number>;
                        values: () => ArrayIterator<number>;
                        includes: (searchElement: number, fromIndex?: number) => boolean;
                        at: (index: number) => number | undefined;
                        findLast: {
                            <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
                            (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
                        };
                        findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
                        toReversed: () => Uint8Array<ArrayBuffer>;
                        toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
                        with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
                        [Symbol.iterator]: () => ArrayIterator<number>;
                        readonly [Symbol.toStringTag]: "Uint8Array";
                    };
                    toHexString: () => string;
                    toString: (encoding?: "hex" | "base64") => string;
                    toJSON: () => string;
                    equals: (otherId: string | import("bson").ObjectId | import("bson").ObjectIdLike | undefined | null) => boolean;
                    getTimestamp: () => Date;
                    inspect: (depth?: number, options?: unknown, inspect?: (x: unknown, options?: unknown) => string) => string;
                };
            } | undefined;
            updated_at?: Date | undefined;
            created_at?: Date | undefined;
            _id: import("bson").ObjectId & string;
        } | undefined;
    };
    credentials: {
        email: string;
        password: string;
    };
    description: {
        indexes?: readonly string[] | undefined;
        form?: readonly string[] | Record<string, string[]> | undefined;
        actions?: import("@aeriajs/types").CollectionActions<any> | undefined;
        individualActions?: import("@aeriajs/types").CollectionActions<any> | undefined;
        layout?: {
            name: import("@aeriajs/types").LayoutName;
            options?: {
                title?: string | undefined;
                picture?: string | undefined;
                badge?: string | undefined;
                information?: string | readonly string[] | undefined;
                active?: string | undefined;
                translateBadge?: boolean | undefined;
            } | undefined;
        } | undefined;
        tableLayout?: {
            actions?: Partial<Record<string | number | symbol, import("@aeriajs/types").TableLayoutAction<any>>> | undefined;
        } | undefined;
        type?: "object" | undefined;
        required?: readonly string[] | Partial<Record<string, boolean | import("@aeriajs/types").Condition<any>>> | undefined;
        table?: readonly string[] | undefined;
        icon?: import("@aeriajs/types").Icon | undefined;
        hidden?: boolean | undefined;
        writable?: readonly string[] | undefined;
        route?: readonly string[] | undefined;
        freshItem?: Partial<Record<string, unknown>> | undefined;
        filters?: readonly (string | {
            property: string;
            default: string;
        })[] | undefined;
        search?: {
            indexes: readonly (string | number | symbol)[];
            placeholder?: string | undefined;
            exactMatches?: boolean | undefined;
        } | undefined;
        filtersPresets?: Record<string, import("@aeriajs/types").FiltersPreset<any>> | undefined;
        tableMeta?: readonly string[] | undefined;
        formLayout?: {
            fields?: Partial<Record<string, import("@aeriajs/types").FormLayoutField<any>>> | undefined;
        } | undefined;
        owned?: import("@aeriajs/types").OwnershipMode | undefined;
        $id: string;
        title?: string | undefined;
        categories?: readonly string[] | undefined;
        preferred?: Record<string, Partial<Pick<any, "form" | "actions" | "individualActions" | "layout" | "tableLayout" | "table" | "filters" | "filtersPresets" | "tableMeta" | "formLayout">>> | undefined;
        defaults?: Record<string, unknown> | undefined;
        unique?: readonly string[] | undefined;
        temporary?: {
            index: string;
            expireAfterSeconds: number;
        } | undefined;
        timestamps?: false | undefined;
        immutable?: boolean | ((doc: import("mongodb").WithId<unknown>) => boolean | Promise<boolean>) | readonly (string | number | symbol)[] | undefined;
        presets?: readonly import("@aeriajs/types").DescriptionPreset[] | undefined;
        properties: {
            roles: {
                items: {
                    enum: string[];
                };
            };
        };
    };
} & import("@aeria-ui/state-management").UnwrapGetters<NonNullable<{
    properties: () => Record<string, import("@aeriajs/types").Property> & {
        roles: {
            items: {
                enum: string[];
            };
        };
    };
    signedIn: () => boolean;
} & {
    $currentLayout: import("vue").ComputedRef<"tabular" | "grid" | "list">;
    $filters: import("vue").ComputedRef<Record<string, unknown>>;
    $freshItem: import("vue").ComputedRef<import("mongodb").WithId<unknown>>;
    actions: import("vue").ComputedRef<import("../index.js").NormalizedActions>;
    condensedItem: import("vue").ComputedRef<unknown>;
    description: import("vue").ComputedRef<Description>;
    diffedItem: import("vue").ComputedRef<Partial<import("mongodb").WithId<unknown>>>;
    filtersCount: import("vue").ComputedRef<number>;
    hasActiveFilters: import("vue").ComputedRef<boolean>;
    hasSelectionActions: import("vue").ComputedRef<boolean>;
    individualActions: import("vue").ComputedRef<import("../index.js").NormalizedActions>;
    isInsertReady: import("vue").ComputedRef<boolean>;
    itemsCount: import("vue").ComputedRef<number>;
    layout: import("vue").ComputedRef<import("@aeriajs/types").Layout>;
    properties: import("vue").ComputedRef<Record<string, import("@aeriajs/types").Property>>;
    references: import("vue").ComputedRef<[string, import("@aeriajs/types").Property][]>;
    tableLayout: import("vue").ComputedRef<import("@aeriajs/types").TableLayout<any>>;
    tableProperties: import("vue").ComputedRef<Record<string, import("@aeriajs/types").Property>>;
}>> & {
    $id: "user";
    $actions: {
        setItem(item: import("../state/collection.js").CollectionStoreItem): import("../state/collection.js").CollectionStoreItem;
        setItems(items: import("../state/collection.js").CollectionStoreItem[]): import("../state/collection.js").CollectionStoreItem[];
        insertItem(_item: import("../state/collection.js").CollectionStoreItem, options?: {
            merge: boolean;
        }): Partial<import("../state/collection.js").CollectionStoreItem> & Record<string, unknown> & {
            _id: any;
        };
        removeItem({ error, result: subject }: Result.Either<import("@aeriajs/types").EndpointError, import("../state/collection.js").CollectionStoreItem>): {
            readonly _tag: "Error";
            readonly error: import("@aeriajs/types").EndpointError;
            readonly result: undefined;
        } | {
            readonly _tag: "Result";
            readonly error: undefined;
            readonly result: import("../state/collection.js").CollectionStoreItem;
        };
        clearItem(): import("../state/collection.js").CollectionStoreItem;
        clearItems(): import("../state/collection.js").CollectionStoreItem[];
        custom<TResponseType = unknown>(verb: string | null, payload?: unknown, options?: import("../index.js").CustomOptions): Promise<TResponseType>;
        count(payload: import("@aeriajs/types").CountPayload<import("../state/collection.js").CollectionStoreItem>): Promise<unknown>;
        get(payload: import("@aeriajs/types").GetPayload<import("../state/collection.js").CollectionStoreItem>, options?: import("../index.js").CustomOptions): Promise<Result.Either<import("@aeriajs/types").EndpointError, import("../state/collection.js").CollectionStoreItem>>;
        retrieveItems(payload?: import("@aeriajs/types").GetAllPayload<import("../state/collection.js").CollectionStoreItem>): Promise<import("@aeriajs/types").GetAllReturnType<import("../state/collection.js").CollectionStoreItem>>;
        getAll(_payload?: import("@aeriajs/types").GetAllPayload<import("../state/collection.js").CollectionStoreItem>): Promise<Result.Either<import("@aeriajs/types").EndpointError, import("../state/collection.js").CollectionStoreItem[]>>;
        insert(payload?: import("@aeriajs/types").InsertPayload<import("../state/collection.js").CollectionStoreItem>, options?: import("../index.js").CustomOptions): Promise<{
            readonly _tag: "Error";
            readonly error: import("@aeriajs/types").EndpointError;
            readonly result: undefined;
        } | {
            readonly _tag: "Result";
            readonly error: undefined;
            readonly result: Partial<import("../state/collection.js").CollectionStoreItem> & Record<string, unknown> & {
                _id: any;
            };
        }>;
        deepInsert(payload?: import("@aeriajs/types").InsertPayload<import("../state/collection.js").CollectionStoreItem>, options?: import("../index.js").CustomOptions): Promise<{
            readonly _tag: "Error";
            readonly error: import("@aeriajs/types").EndpointError;
            readonly result: undefined;
        } | {
            readonly _tag: "Result";
            readonly error: undefined;
            readonly result: Partial<import("../state/collection.js").CollectionStoreItem> & Record<string, unknown> & {
                _id: any;
            };
        }>;
        remove(payload: import("@aeriajs/types").RemovePayload<import("../state/collection.js").CollectionStoreItem>, options?: import("../index.js").CustomOptions): Promise<{
            readonly _tag: "Error";
            readonly error: import("@aeriajs/types").EndpointError;
            readonly result: undefined;
        } | {
            readonly _tag: "Result";
            readonly error: undefined;
            readonly result: import("../state/collection.js").CollectionStoreItem;
        }>;
        removeAll(payload: import("@aeriajs/types").RemoveAllPayload, options?: import("../index.js").CustomOptions): Promise<Result.Either<import("@aeriajs/types").EndpointError, unknown>>;
        filter(props?: import("@aeriajs/types").GetAllPayload<import("../state/collection.js").CollectionStoreItem>): Promise<Result.Either<import("@aeriajs/types").EndpointError, import("../state/collection.js").CollectionStoreItem[]>>;
        updateItems(): Promise<Result.Either<import("@aeriajs/types").EndpointError, import("../state/collection.js").CollectionStoreItem[]>>;
        clearFilters(): Record<string, unknown>;
        useProperties(properties: (string)[]): {};
        usePropertiesExcept(properties: (string)[]): {
            [k: string]: import("@aeriajs/types").Property;
        };
        formatValue(args: {
            value: unknown;
            key: string;
            form?: boolean;
            property: import("@aeriajs/types").Property;
            index?: string;
        }): unknown;
        select(properties: (string)[], item?: import("../state/collection.js").CollectionStoreItem): {};
        selectManyItems(items: import("../state/collection.js").CollectionStoreItem[], value?: boolean): import("../state/collection.js").CollectionStoreItem[];
        selectAllItems(state?: boolean): import("../state/collection.js").CollectionStoreItem[];
    } & {
        setCurrentUser: (auth: SuccessfulAuthentication | null) => void;
        signout: () => void;
        authenticate(payload: Credentials | {
            revalidate: true;
        }): Promise<{
            readonly _tag: "Error";
            readonly error: (Pick<Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                readonly httpStatus: {
                    readonly enum: [401];
                };
                readonly code: {
                    readonly enum: ["AUTHORIZATION_ERROR", "INVALID_CREDENTIALS", "INACTIVE_USER"];
                };
                readonly message: {
                    readonly type: "string";
                };
                readonly details: {
                    readonly type: "object";
                    readonly additionalProperties: true;
                };
            }, {}>> & {
                code: "AUTHORIZATION_ERROR" | "INVALID_CREDENTIALS" | "INACTIVE_USER";
                httpStatus: 401;
                message: string;
                details: any;
            }, never>, "httpStatus" | "code"> & Partial<Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                readonly httpStatus: {
                    readonly enum: [401];
                };
                readonly code: {
                    readonly enum: ["AUTHORIZATION_ERROR", "INVALID_CREDENTIALS", "INACTIVE_USER"];
                };
                readonly message: {
                    readonly type: "string";
                };
                readonly details: {
                    readonly type: "object";
                    readonly additionalProperties: true;
                };
            }, {}>> & {
                code: "AUTHORIZATION_ERROR" | "INVALID_CREDENTIALS" | "INACTIVE_USER";
                httpStatus: 401;
                message: string;
                details: any;
            }, never>>) | (Pick<Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                readonly httpStatus: {
                    readonly enum: [401];
                };
                readonly code: {
                    readonly enum: ["AUTHORIZATION_ERROR", "INVALID_CREDENTIALS", "INACTIVE_USER"];
                };
                readonly message: {
                    readonly type: "string";
                };
                readonly details: {
                    readonly type: "object";
                    readonly additionalProperties: true;
                };
            }, {}>> & {
                code: "AUTHORIZATION_ERROR" | "INVALID_CREDENTIALS" | "INACTIVE_USER";
                httpStatus: 401;
                message: string;
                details: any;
            }, never>, "httpStatus" | "code"> & Partial<Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                readonly httpStatus: {
                    readonly enum: [401];
                };
                readonly code: {
                    readonly enum: ["AUTHORIZATION_ERROR", "INVALID_CREDENTIALS", "INACTIVE_USER"];
                };
                readonly message: {
                    readonly type: "string";
                };
                readonly details: {
                    readonly type: "object";
                    readonly additionalProperties: true;
                };
            }, {}>> & {
                code: "AUTHORIZATION_ERROR" | "INVALID_CREDENTIALS" | "INACTIVE_USER";
                httpStatus: 401;
                message: string;
                details: any;
            }, never>>);
            readonly result: undefined;
        } | {
            readonly _tag: "Result";
            readonly error: undefined;
            readonly result: ({
                user: import("@aeriajs/types").SchemaWithId<{
                    readonly $id: "user";
                    readonly icon: "users";
                    readonly required: readonly ["name", "roles", "email"];
                    readonly form: readonly ["name", "active", "roles", "email", "phone_number", "picture_file"];
                    readonly indexes: readonly ["name"];
                    readonly unique: readonly ["email"];
                    readonly properties: {
                        readonly name: {
                            readonly type: "string";
                            readonly minLength: 1;
                        };
                        readonly given_name: {
                            readonly type: "getter";
                            readonly getter: (doc: object) => string | undefined;
                        };
                        readonly family_name: {
                            readonly type: "getter";
                            readonly getter: (doc: object) => string | undefined;
                        };
                        readonly active: {
                            readonly type: "boolean";
                        };
                        readonly roles: {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "string";
                            };
                            readonly uniqueItems: true;
                            readonly minItems: 1;
                        };
                        readonly email: {
                            readonly type: "string";
                            readonly inputType: "email";
                            readonly minLength: 3;
                        };
                        readonly password: {
                            readonly type: "string";
                            readonly inputType: "password";
                            readonly hidden: true;
                        };
                        readonly phone_number: {
                            readonly type: "string";
                            readonly mask: "(##) #####-####";
                        };
                        readonly picture_file: {
                            readonly $ref: "file";
                            readonly accept: readonly ["image/*"];
                        };
                        readonly picture: {
                            readonly type: "getter";
                            readonly getter: (doc: object) => Promise<string> | undefined;
                        };
                        readonly self_registered: {
                            readonly type: "boolean";
                            readonly readOnly: true;
                        };
                        readonly updated_at: {
                            readonly type: "string";
                            readonly format: "date-time";
                        };
                    };
                    readonly presets: readonly ["crud", "duplicate"];
                    readonly layout: {
                        readonly name: "grid";
                        readonly options: {
                            readonly title: "name";
                            readonly badge: "roles";
                            readonly picture: "picture_file";
                            readonly information: "email";
                            readonly active: "active";
                            readonly translateBadge: true;
                        };
                    };
                    readonly individualActions: {
                        readonly changePassword: {
                            readonly label: "change_password";
                            readonly icon: "key";
                            readonly translate: true;
                            readonly route: {
                                readonly name: "/dashboard/user/changepass";
                                readonly fetchItem: true;
                            };
                        };
                        readonly copyRedefinePasswordLink: {
                            readonly label: "copy_redefine_password_link";
                            readonly icon: "link";
                            readonly translate: true;
                        };
                        readonly copyActivationLink: {
                            readonly label: "copy_activation_link";
                            readonly icon: "link";
                            readonly translate: true;
                        };
                    };
                    readonly filters: readonly ["name", "roles", "email", "phone_number"];
                    readonly table: readonly ["name", "roles", "picture_file", "active", "updated_at"];
                    readonly tableMeta: readonly ["email"];
                    readonly formLayout: {
                        readonly fields: {
                            readonly given_name: {
                                readonly span: 3;
                            };
                            readonly family_name: {
                                readonly span: 3;
                            };
                        };
                    };
                }>;
            } & Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                readonly user: {
                    readonly $ref: "user";
                };
                readonly token: {
                    readonly type: "object";
                    readonly properties: {
                        readonly type: {
                            readonly enum: readonly ["bearer"];
                        };
                        readonly content: {
                            readonly type: "string";
                        };
                    };
                };
            }, {}>> & {
                user: never;
                token: {} & Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                    readonly type: {
                        readonly enum: readonly ["bearer"];
                    };
                    readonly content: {
                        readonly type: "string";
                    };
                }, {}>> & {
                    type: "bearer";
                    content: string;
                }, never>;
            }, "user">) | Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                readonly user: {
                    readonly type: "object";
                    readonly properties: {
                        readonly _id: {
                            readonly const: null;
                        };
                        readonly name: {
                            readonly type: "string";
                        };
                        readonly email: {
                            readonly type: "string";
                        };
                        readonly roles: {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "string";
                            };
                        };
                        readonly active: {
                            readonly type: "boolean";
                        };
                    };
                };
                readonly token: {
                    readonly type: "object";
                    readonly properties: {
                        readonly type: {
                            readonly type: "string";
                        };
                        readonly content: {
                            readonly type: "string";
                        };
                    };
                };
            }, {}>> & {
                user: {} & Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                    readonly _id: {
                        readonly const: null;
                    };
                    readonly name: {
                        readonly type: "string";
                    };
                    readonly email: {
                        readonly type: "string";
                    };
                    readonly roles: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                    };
                    readonly active: {
                        readonly type: "boolean";
                    };
                }, {}>> & {
                    name: string;
                    _id: null;
                    roles: string[];
                    email: string;
                    active: boolean;
                }, never>;
                token: {} & Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                    readonly type: {
                        readonly type: "string";
                    };
                    readonly content: {
                        readonly type: "string";
                    };
                }, {}>> & {
                    type: string;
                    content: string;
                }, never>;
            }, never> | ({
                user: import("@aeriajs/types").SchemaWithId<{
                    readonly $id: "user";
                    readonly icon: "users";
                    readonly required: readonly ["name", "roles", "email"];
                    readonly form: readonly ["name", "active", "roles", "email", "phone_number", "picture_file"];
                    readonly indexes: readonly ["name"];
                    readonly unique: readonly ["email"];
                    readonly properties: {
                        readonly name: {
                            readonly type: "string";
                            readonly minLength: 1;
                        };
                        readonly given_name: {
                            readonly type: "getter";
                            readonly getter: (doc: object) => string | undefined;
                        };
                        readonly family_name: {
                            readonly type: "getter";
                            readonly getter: (doc: object) => string | undefined;
                        };
                        readonly active: {
                            readonly type: "boolean";
                        };
                        readonly roles: {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "string";
                            };
                            readonly uniqueItems: true;
                            readonly minItems: 1;
                        };
                        readonly email: {
                            readonly type: "string";
                            readonly inputType: "email";
                            readonly minLength: 3;
                        };
                        readonly password: {
                            readonly type: "string";
                            readonly inputType: "password";
                            readonly hidden: true;
                        };
                        readonly phone_number: {
                            readonly type: "string";
                            readonly mask: "(##) #####-####";
                        };
                        readonly picture_file: {
                            readonly $ref: "file";
                            readonly accept: readonly ["image/*"];
                        };
                        readonly picture: {
                            readonly type: "getter";
                            readonly getter: (doc: object) => Promise<string> | undefined;
                        };
                        readonly self_registered: {
                            readonly type: "boolean";
                            readonly readOnly: true;
                        };
                        readonly updated_at: {
                            readonly type: "string";
                            readonly format: "date-time";
                        };
                    };
                    readonly presets: readonly ["crud", "duplicate"];
                    readonly layout: {
                        readonly name: "grid";
                        readonly options: {
                            readonly title: "name";
                            readonly badge: "roles";
                            readonly picture: "picture_file";
                            readonly information: "email";
                            readonly active: "active";
                            readonly translateBadge: true;
                        };
                    };
                    readonly individualActions: {
                        readonly changePassword: {
                            readonly label: "change_password";
                            readonly icon: "key";
                            readonly translate: true;
                            readonly route: {
                                readonly name: "/dashboard/user/changepass";
                                readonly fetchItem: true;
                            };
                        };
                        readonly copyRedefinePasswordLink: {
                            readonly label: "copy_redefine_password_link";
                            readonly icon: "link";
                            readonly translate: true;
                        };
                        readonly copyActivationLink: {
                            readonly label: "copy_activation_link";
                            readonly icon: "link";
                            readonly translate: true;
                        };
                    };
                    readonly filters: readonly ["name", "roles", "email", "phone_number"];
                    readonly table: readonly ["name", "roles", "picture_file", "active", "updated_at"];
                    readonly tableMeta: readonly ["email"];
                    readonly formLayout: {
                        readonly fields: {
                            readonly given_name: {
                                readonly span: 3;
                            };
                            readonly family_name: {
                                readonly span: 3;
                            };
                        };
                    };
                }>;
            } & Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                readonly user: {
                    readonly $ref: "user";
                };
                readonly token: {
                    readonly type: "object";
                    readonly properties: {
                        readonly type: {
                            readonly enum: readonly ["bearer"];
                        };
                        readonly content: {
                            readonly type: "string";
                        };
                    };
                };
            }, {}>> & {
                user: never;
                token: {} & Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                    readonly type: {
                        readonly enum: readonly ["bearer"];
                    };
                    readonly content: {
                        readonly type: "string";
                    };
                }, {}>> & {
                    type: "bearer";
                    content: string;
                }, never>;
            }, "user">) | Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                readonly user: {
                    readonly type: "object";
                    readonly properties: {
                        readonly _id: {
                            readonly const: null;
                        };
                        readonly name: {
                            readonly type: "string";
                        };
                        readonly email: {
                            readonly type: "string";
                        };
                        readonly roles: {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "string";
                            };
                        };
                        readonly active: {
                            readonly type: "boolean";
                        };
                    };
                };
                readonly token: {
                    readonly type: "object";
                    readonly properties: {
                        readonly type: {
                            readonly type: "string";
                        };
                        readonly content: {
                            readonly type: "string";
                        };
                    };
                };
            }, {}>> & {
                user: {} & Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                    readonly _id: {
                        readonly const: null;
                    };
                    readonly name: {
                        readonly type: "string";
                    };
                    readonly email: {
                        readonly type: "string";
                    };
                    readonly roles: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                    };
                    readonly active: {
                        readonly type: "boolean";
                    };
                }, {}>> & {
                    name: string;
                    _id: null;
                    roles: string[];
                    email: string;
                    active: boolean;
                }, never>;
                token: {} & Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
                    readonly type: {
                        readonly type: "string";
                    };
                    readonly content: {
                        readonly type: "string";
                    };
                }, {}>> & {
                    type: string;
                    content: string;
                }, never>;
            }, never>;
        }>;
        copyRedefinePasswordLink({ filters }: IndividualActionPayload<{
            _id: string;
        }>): Promise<void>;
        copyActivationLink({ filters }: IndividualActionPayload<{
            _id: string;
        }>): Promise<void>;
    };
    $functions: Record<string, (...args: unknown[]) => unknown>;
};