@fabriktor/fx 0.0.31 → 0.0.33

package/dist/src/billable/billable.d.ts

@@ -1,28 +1,29 @@
-import type { InBill, OperationResult, PLBillablePeriodsFromDates, PLBillableSetItemQuantity, PLBillableVendorInvoiceFromBill, PLBillableYearSpan, RPBillablePeriodsFromDates, YearSpan } from "@fabriktor/schema";
+import type { OperationResult, RPBillablePeriodsFromDates, YearSpan } from "@fabriktor/schema";
 import type { BillableOperator, OperationResultOf } from "@fabriktor/client";
+type GenerateBillPayload = Parameters<BillableOperator["generateBill"]>[0];
 export type BillableFXOptions = {
     billable: BillableOperator;
 };
 export type GenerateFixedEstimateOptions = {
-    in: InBill;
+    in: GenerateBillPayload;
 };
 export type AcceptFixedEstimateOptions = {
-    in: InBill;
+    in: GenerateBillPayload;
 };
 export type GenerateDynamicEstimateOptions = {
-    in: InBill;
+    in: GenerateBillPayload;
 };
 export type GenerateDynamicBillOptions = {
-    in: InBill;
+    in: GenerateBillPayload;
     exclude_billed?: boolean;
 };
 export type MarkLocationAchievedOptions = {
-    in: InBill;
+    in: GenerateBillPayload;
 };
-export type YearSpanOptions = PLBillableYearSpan;
-export type PeriodsFromDatesOptions = PLBillablePeriodsFromDates;
-export type VendorInvoiceFromBillOptions = PLBillableVendorInvoiceFromBill;
-export type SetItemQuantityOptions = PLBillableSetItemQuantity;
+export type YearSpanOptions = Parameters<BillableOperator["yearSpan"]>[0];
+export type PeriodsFromDatesOptions = Parameters<BillableOperator["periodsFromDates"]>[0];
+export type VendorInvoiceFromBillOptions = Parameters<BillableOperator["vendorInvoiceFromBill"]>[0];
+export type SetItemQuantityOptions = Parameters<BillableOperator["setItemQuantity"]>[0];
 export interface BillableFXOperator {
     generateFixedEstimate(opts: GenerateFixedEstimateOptions): Promise<OperationResult>;
     acceptFixedEstimate(opts: AcceptFixedEstimateOptions): Promise<OperationResult>;
@@ -48,3 +49,4 @@ export declare class BillableFX implements BillableFXOperator {
     setItemQuantity(opts: SetItemQuantityOptions): Promise<void>;
 }
 export declare function newBillableFX(opts: BillableFXOptions): BillableFX;
+export {};

package/dist/src/billable/billable.js

@@ -57,11 +57,10 @@ export function newBillableFX(opts) {
     return new BillableFX(opts);
 }
 function billWith(x, overrides) {
-    const out = {
+    return {
         ...x,
         ...defined(overrides),
     };
-    return out;
 }
 function defined(x) {
     const out = {};

package/dist/src/calls/calls.d.ts

@@ -1,16 +1,16 @@
-import type { PLCallsMintVideoToken, PLNotificationsRelay } from "@fabriktor/schema";
 import type { CallsOperator, NotificationsOperator } from "@fabriktor/client";
-export type MintVideoTokenOptions = PLCallsMintVideoToken;
+export type MintVideoTokenOptions = Parameters<CallsOperator["mintVideoToken"]>[0];
+export type RelayNotificationOptions = Parameters<NotificationsOperator["relayNotification"]>[0];
 export type StartCallOptions = {
     mint: MintVideoTokenOptions;
-    notification: PLNotificationsRelay;
+    notification: RelayNotificationOptions;
 };
 export type AnswerCallOptions = {
     mint: MintVideoTokenOptions;
-    self_notification: PLNotificationsRelay;
+    self_notification: RelayNotificationOptions;
 };
 export type CancelCallOptions = {
-    notification: PLNotificationsRelay;
+    notification: RelayNotificationOptions;
 };
 export type CallsFXOptions = {
     calls: CallsOperator;

package/dist/src/calls/calls.js

@@ -3,7 +3,9 @@
 // Licensed under the Apache License, Version 2.0 (the "License"); you may
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-import { errVideoTokenMintFailed } from "../core/err.js";
+import { errResolveFailed } from "../core/err.js";
+const resourceVideoToken = "video_token";
+const msgUnableToMintVideoToken = "Unable to mint video token.";
 export class CallsFX {
     calls;
     notifications;
@@ -26,10 +28,14 @@ export class CallsFX {
     }
     async requireVideoToken(opts) {
         const out = await this.calls.mintVideoToken(opts);
-        if (out.value === undefined || out.value.trim() === "") {
-            throw errVideoTokenMintFailed();
+        const token = out.value?.trim();
+        if (token === undefined || token === "") {
+            throw errResolveFailed({
+                resource: resourceVideoToken,
+                msg: msgUnableToMintVideoToken,
+            });
         }
-        return out.value;
+        return token;
     }
 }
 export function newCallsFX(opts) {

package/dist/src/chat/chat.d.ts

@@ -0,0 +1,90 @@
+import { type Chat, type ChatRoom, type ChatRoomMember } from "@fabriktor/schema";
+import type { ChatOperator, WSCloseHandler, WSConnection, WSErrorHandler, WSMessageHandler } from "@fabriktor/client";
+export type ReactChatOptions = Parameters<ChatOperator["reactChat"]>[0];
+export type ChatFXOptions = {
+    chat: ChatOperator;
+};
+export type LatestChatsOptions = {
+    chat_room_id: string;
+    page?: number;
+    per_page?: number;
+};
+export type LatestChatsCursor = {
+    chat_room_id: string;
+    next_page: number;
+    per_page: number;
+    done: boolean;
+};
+export type NextLatestChatsOptions = {
+    cursor: LatestChatsCursor;
+};
+export type LatestChatsPage = {
+    chats: Chat[];
+    page: number;
+    per_page: number;
+    total_count?: number;
+    last_page?: number;
+    has_more: boolean;
+    next_cursor: LatestChatsCursor;
+};
+export type ChatRoomMembersOptions = {
+    chat_room_id: string;
+};
+export type MyChatRoomMembersOptions = {
+    owner_id: string;
+};
+export type OpenChatRoomOptions = {
+    owner_id: string;
+    chat_room_id: string;
+    per_page?: number;
+    on_chat: WSMessageHandler<Chat>;
+    on_chat_room: WSMessageHandler<ChatRoom>;
+    on_error?: WSErrorHandler;
+    on_close?: WSCloseHandler;
+};
+export type OpenGlobalChatRoomsOptions = {
+    owner_id: string;
+    on_chat_room: WSMessageHandler<ChatRoom>;
+    on_error?: WSErrorHandler;
+    on_close?: WSCloseHandler;
+};
+export type ReactUploadedChatOptions = {
+    chat: Chat;
+    reaction: ReactChatOptions;
+};
+export type ChatRoomSession = {
+    latest: LatestChatsPage;
+    chats_ws: WSConnection;
+    chat_room_ws: WSConnection;
+    closeNormal(reason?: string): void;
+    closeLeavingPage(reason?: string): void;
+};
+export type GlobalChatRoomsSession = {
+    members: ChatRoomMember[];
+    chat_rooms_ws: WSConnection;
+    closeNormal(reason?: string): void;
+    closeLeavingPage(reason?: string): void;
+};
+export interface ChatFXOperator {
+    newLatestChatsCursor(opts: LatestChatsOptions): LatestChatsCursor;
+    latestChats(opts: LatestChatsOptions): Promise<LatestChatsPage>;
+    nextLatestChats(opts: NextLatestChatsOptions): Promise<LatestChatsPage>;
+    chatRoomMembers(opts: ChatRoomMembersOptions): Promise<ChatRoomMember[]>;
+    myChatRoomMembers(opts: MyChatRoomMembersOptions): Promise<ChatRoomMember[]>;
+    openChatRoom(opts: OpenChatRoomOptions): Promise<ChatRoomSession>;
+    openGlobalChatRooms(opts: OpenGlobalChatRoomsOptions): Promise<GlobalChatRoomsSession>;
+    reactUploadedChat(opts: ReactUploadedChatOptions): Promise<void>;
+}
+export declare class ChatFX implements ChatFXOperator {
+    private chat;
+    constructor(opts: ChatFXOptions);
+    newLatestChatsCursor(opts: LatestChatsOptions): LatestChatsCursor;
+    latestChats(opts: LatestChatsOptions): Promise<LatestChatsPage>;
+    nextLatestChats(opts: NextLatestChatsOptions): Promise<LatestChatsPage>;
+    chatRoomMembers(opts: ChatRoomMembersOptions): Promise<ChatRoomMember[]>;
+    myChatRoomMembers(opts: MyChatRoomMembersOptions): Promise<ChatRoomMember[]>;
+    openChatRoom(opts: OpenChatRoomOptions): Promise<ChatRoomSession>;
+    openGlobalChatRooms(opts: OpenGlobalChatRoomsOptions): Promise<GlobalChatRoomsSession>;
+    reactUploadedChat(opts: ReactUploadedChatOptions): Promise<void>;
+}
+export declare function newChatFX(opts: ChatFXOptions): ChatFX;

package/dist/src/chat/chat.js

@@ -0,0 +1,194 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+import { SearchPageKey, SearchPerPageKey, SearchResultResultsKey, } from "@fabriktor/schema";
+import { errValidation } from "../core/err.js";
+const firstPage = 1;
+const defaultPerPage = 30;
+const closeCodeNormal = 1000;
+const closeCodeLeavingPage = 1001;
+const msgChatObjectsUploading = "Cannot react to a chat while objects are still uploading.";
+export class ChatFX {
+    chat;
+    constructor(opts) {
+        this.chat = opts.chat;
+    }
+    newLatestChatsCursor(opts) {
+        return {
+            chat_room_id: opts.chat_room_id,
+            next_page: normalizePage(opts.page),
+            per_page: normalizePerPage(opts.per_page),
+            done: false,
+        };
+    }
+    async latestChats(opts) {
+        const page = normalizePage(opts.page);
+        const per_page = normalizePerPage(opts.per_page);
+        const raw = await this.chat.searchManyChats({
+            query: {
+                chat_room_id: opts.chat_room_id,
+                [SearchPageKey]: page,
+                [SearchPerPageKey]: per_page,
+            },
+        });
+        return latestChatsPage({
+            chat_room_id: opts.chat_room_id,
+            page,
+            per_page,
+            raw,
+        });
+    }
+    async nextLatestChats(opts) {
+        if (opts.cursor.done) {
+            return emptyLatestChatsPage(opts.cursor);
+        }
+        return await this.latestChats({
+            chat_room_id: opts.cursor.chat_room_id,
+            page: opts.cursor.next_page,
+            per_page: opts.cursor.per_page,
+        });
+    }
+    async chatRoomMembers(opts) {
+        const out = await this.chat.queryChatRoomMembers({
+            query: {
+                chat_room_id: opts.chat_room_id,
+            },
+        });
+        return out.value ?? [];
+    }
+    async myChatRoomMembers(opts) {
+        const out = await this.chat.queryChatRoomMembers({
+            query: {
+                owner_id: opts.owner_id,
+            },
+        });
+        return out.value ?? [];
+    }
+    async openChatRoom(opts) {
+        const latest = await this.latestChats({
+            chat_room_id: opts.chat_room_id,
+            per_page: opts.per_page,
+        });
+        const chats_ws = await this.chat.wsChats({
+            owner_id: opts.owner_id,
+            chat_room_id: opts.chat_room_id,
+            on_message: opts.on_chat,
+            on_error: opts.on_error,
+            on_close: opts.on_close,
+        });
+        const chat_room_ws = await this.chat.wsChatRoom({
+            id: opts.chat_room_id,
+            on_message: opts.on_chat_room,
+            on_error: opts.on_error,
+            on_close: opts.on_close,
+        });
+        return {
+            latest,
+            chats_ws,
+            chat_room_ws,
+            closeNormal(reason) {
+                closeWS([chats_ws, chat_room_ws], closeCodeNormal, reason);
+            },
+            closeLeavingPage(reason) {
+                closeWS([chats_ws, chat_room_ws], closeCodeLeavingPage, reason);
+            },
+        };
+    }
+    async openGlobalChatRooms(opts) {
+        const members = await this.myChatRoomMembers({
+            owner_id: opts.owner_id,
+        });
+        const chat_rooms_ws = await this.chat.wsMineChatRooms({
+            owner_id: opts.owner_id,
+            on_message: opts.on_chat_room,
+            on_error: opts.on_error,
+            on_close: opts.on_close,
+        });
+        return {
+            members,
+            chat_rooms_ws,
+            closeNormal(reason) {
+                closeWS([chat_rooms_ws], closeCodeNormal, reason);
+            },
+            closeLeavingPage(reason) {
+                closeWS([chat_rooms_ws], closeCodeLeavingPage, reason);
+            },
+        };
+    }
+    async reactUploadedChat(opts) {
+        if (opts.chat.has_objects && !opts.chat.objects_uploaded) {
+            throw errValidation({
+                field: "chat_id",
+                msg: msgChatObjectsUploading,
+            });
+        }
+        await this.chat.reactChat(opts.reaction);
+    }
+}
+export function newChatFX(opts) {
+    return new ChatFX(opts);
+}
+function latestChatsPage(opts) {
+    const value = opts.raw.value;
+    const chats = value?.[SearchResultResultsKey] ?? [];
+    const total_count = value?.total_count;
+    const last_page = value?.last_page;
+    const has_more = hasMoreChats({
+        chats,
+        page: opts.page,
+        per_page: opts.per_page,
+        total_count,
+        last_page,
+    });
+    return {
+        chats,
+        page: opts.page,
+        per_page: opts.per_page,
+        total_count,
+        last_page,
+        has_more,
+        next_cursor: {
+            chat_room_id: opts.chat_room_id,
+            next_page: has_more ? opts.page + 1 : opts.page,
+            per_page: opts.per_page,
+            done: !has_more,
+        },
+    };
+}
+function emptyLatestChatsPage(cursor) {
+    return {
+        chats: [],
+        page: cursor.next_page,
+        per_page: cursor.per_page,
+        has_more: false,
+        next_cursor: cursor,
+    };
+}
+function hasMoreChats(opts) {
+    if (opts.last_page !== undefined) {
+        return opts.page < opts.last_page;
+    }
+    if (opts.total_count !== undefined) {
+        return opts.page * opts.per_page < opts.total_count;
+    }
+    return opts.chats.length >= opts.per_page;
+}
+function closeWS(conns, code, reason) {
+    for (const conn of conns) {
+        conn.close(code, reason);
+    }
+}
+function normalizePage(v) {
+    if (v === undefined || !Number.isFinite(v)) {
+        return firstPage;
+    }
+    return Math.max(firstPage, Math.trunc(v));
+}
+function normalizePerPage(v) {
+    if (v === undefined || !Number.isFinite(v)) {
+        return defaultPerPage;
+    }
+    return Math.max(1, Math.trunc(v));
+}

package/dist/src/contacts/contacts.d.ts

@@ -0,0 +1,67 @@
+import { Friend, Hired, Manager, Na, OldHire, type Contact, type ID, type OperationResult } from "@fabriktor/schema";
+import type { ContactsOperator } from "@fabriktor/client";
+export type ContactRelation = typeof Na | typeof Friend | typeof OldHire | typeof Hired | typeof Manager;
+export type ActiveContactRelation = typeof Friend | typeof Hired | typeof Manager;
+export type ContactsFXOptions = {
+    contacts: ContactsOperator;
+};
+export type LoadContactIndexOptions = {
+    owner_id: string;
+};
+export type ContactIndex = {
+    contacts: Contact[];
+    peer_ids: Set<string>;
+};
+export type PresenceActiveHandler = (active_ids: ID[]) => void;
+export type PresenceErrorHandler = (err: unknown) => void;
+export type StartPresenceOptions = {
+    on_active: PresenceActiveHandler;
+    on_error?: PresenceErrorHandler;
+};
+export type PresenceSession = {
+    stop(): void;
+};
+export type SendFriendRequestOptions = {
+    contact_id: string;
+};
+export type RequestRelationUpgradeOptions = {
+    contact: Contact;
+    requested_relation: ActiveContactRelation;
+};
+export type DowngradeRelationOptions = {
+    contact: Contact;
+    relation: ActiveContactRelation;
+};
+export type AcceptContactRequestOptions = {
+    contact: Contact;
+};
+export type RejectContactRequestOptions = {
+    contact: Contact;
+};
+export type EndHireRelationOptions = {
+    contact: Contact;
+};
+export interface ContactsFXOperator {
+    loadContactIndex(opts: LoadContactIndexOptions): Promise<ContactIndex>;
+    startPresence(opts: StartPresenceOptions): Promise<PresenceSession>;
+    sendFriendRequest(opts: SendFriendRequestOptions): Promise<OperationResult>;
+    requestRelationUpgrade(opts: RequestRelationUpgradeOptions): Promise<OperationResult>;
+    downgradeRelation(opts: DowngradeRelationOptions): Promise<OperationResult>;
+    acceptContactRequest(opts: AcceptContactRequestOptions): Promise<OperationResult>;
+    rejectContactRequest(opts: RejectContactRequestOptions): Promise<OperationResult>;
+    endHireRelation(opts: EndHireRelationOptions): Promise<OperationResult>;
+}
+export declare class ContactsFX implements ContactsFXOperator {
+    private contacts;
+    constructor(opts: ContactsFXOptions);
+    loadContactIndex(opts: LoadContactIndexOptions): Promise<ContactIndex>;
+    startPresence(opts: StartPresenceOptions): Promise<PresenceSession>;
+    sendFriendRequest(opts: SendFriendRequestOptions): Promise<OperationResult>;
+    requestRelationUpgrade(opts: RequestRelationUpgradeOptions): Promise<OperationResult>;
+    downgradeRelation(opts: DowngradeRelationOptions): Promise<OperationResult>;
+    acceptContactRequest(opts: AcceptContactRequestOptions): Promise<OperationResult>;
+    rejectContactRequest(opts: RejectContactRequestOptions): Promise<OperationResult>;
+    endHireRelation(opts: EndHireRelationOptions): Promise<OperationResult>;
+    private replaceContact;
+}
+export declare function newContactsFX(opts: ContactsFXOptions): ContactsFX;

package/dist/src/contacts/contacts.js

@@ -0,0 +1,179 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+import { Friend, Na, OldHire, } from "@fabriktor/schema";
+import { errRequired, errValidation } from "../core/err.js";
+const presenceIntervalMS = 120_000;
+const msgOwnerIDRequired = "Owner ID is required.";
+const msgContactIDRequired = "Contact ID is required.";
+const msgRelationUpgradeInvalid = "Requested relation must be higher than the current relation.";
+const msgRelationDowngradeInvalid = "Requested relation must be lower than the current relation.";
+const msgPendingRelationRequired = "Contact request does not contain a pending relation.";
+export class ContactsFX {
+    contacts;
+    constructor(opts) {
+        this.contacts = opts.contacts;
+    }
+    async loadContactIndex(opts) {
+        const owner_id = opts.owner_id.trim();
+        if (owner_id === "") {
+            throw errRequired({
+                field: "owner_id",
+                msg: msgOwnerIDRequired,
+            });
+        }
+        const out = await this.contacts.findContacts();
+        const contacts = out.value ?? [];
+        const peer_ids = new Set();
+        for (const contact of contacts) {
+            const peer_id = contactPeerID(contact, owner_id);
+            if (peer_id !== undefined) {
+                peer_ids.add(peer_id);
+            }
+        }
+        return {
+            contacts,
+            peer_ids,
+        };
+    }
+    async startPresence(opts) {
+        const initial = await this.contacts.signal();
+        opts.on_active(initial.value ?? []);
+        let stopped = false;
+        let running = false;
+        const tick = async () => {
+            if (stopped || running) {
+                return;
+            }
+            running = true;
+            try {
+                const out = await this.contacts.signal();
+                if (!stopped) {
+                    opts.on_active(out.value ?? []);
+                }
+            }
+            catch (err) {
+                if (!stopped) {
+                    opts.on_error?.(err);
+                }
+            }
+            finally {
+                running = false;
+            }
+        };
+        const timer = setInterval(() => {
+            void tick();
+        }, presenceIntervalMS);
+        return {
+            stop() {
+                if (stopped) {
+                    return;
+                }
+                stopped = true;
+                clearInterval(timer);
+            },
+        };
+    }
+    async sendFriendRequest(opts) {
+        const contact_id = opts.contact_id.trim();
+        if (contact_id === "") {
+            throw errRequired({
+                field: "contact_id",
+                msg: msgContactIDRequired,
+            });
+        }
+        return await this.contacts.insertOneContact({
+            in: {
+                contact_id,
+                is_pending: true,
+                relation: Na,
+                requested_relation: Friend,
+                is_archived: false,
+            },
+        });
+    }
+    async requestRelationUpgrade(opts) {
+        if (opts.requested_relation <= opts.contact.relation) {
+            throw errValidation({
+                field: "requested_relation",
+                msg: msgRelationUpgradeInvalid,
+            });
+        }
+        return await this.replaceContact(opts.contact, {
+            is_pending: true,
+            relation: opts.contact.relation,
+            requested_relation: opts.requested_relation,
+            is_archived: false,
+        });
+    }
+    async downgradeRelation(opts) {
+        if (opts.relation >= opts.contact.relation) {
+            throw errValidation({
+                field: "relation",
+                msg: msgRelationDowngradeInvalid,
+            });
+        }
+        return await this.replaceContact(opts.contact, {
+            is_pending: false,
+            relation: opts.relation,
+            requested_relation: Na,
+            is_archived: false,
+        });
+    }
+    async acceptContactRequest(opts) {
+        if (opts.contact.requested_relation === Na) {
+            throw errValidation({
+                field: "contact",
+                msg: msgPendingRelationRequired,
+            });
+        }
+        return await this.replaceContact(opts.contact, {
+            is_pending: false,
+            relation: opts.contact.requested_relation,
+            requested_relation: Na,
+            is_archived: false,
+        });
+    }
+    async rejectContactRequest(opts) {
+        return await this.replaceContact(opts.contact, {
+            is_archived: true,
+        });
+    }
+    async endHireRelation(opts) {
+        return await this.replaceContact(opts.contact, {
+            is_pending: false,
+            relation: OldHire,
+            requested_relation: Na,
+            is_archived: false,
+        });
+    }
+    async replaceContact(contact, overrides) {
+        return await this.contacts.replaceOneContact({
+            id: contact.id,
+            in: {
+                contact_id: contact.contact_id,
+                is_pending: contact.is_pending,
+                relation: contact.relation,
+                requested_relation: contact.requested_relation,
+                is_archived: contact.is_archived,
+                ...overrides,
+            },
+        });
+    }
+}
+export function newContactsFX(opts) {
+    return new ContactsFX(opts);
+}
+function contactPeerID(contact, owner_id) {
+    const contact_owner_id = contact.owner_id.trim();
+    const contact_id = contact.contact_id.trim();
+    if (contact_owner_id === owner_id && contact_id !== "") {
+        return contact_id;
+    }
+    if (contact_id === owner_id && contact_owner_id !== "") {
+        return contact_owner_id;
+    }
+    return undefined;
+}

package/dist/src/core/err.d.ts

@@ -29,11 +29,6 @@ export type ResolveFailedFXErrOptions<T extends object = Record<string, unknown>
     field?: FieldOf<T>;
     cause?: unknown;
 };
-export type UsernameInvalidFXErrOptions<T extends object = Record<string, unknown>> = {
-    field: FieldOf<T>;
-    msg: string;
-    cause?: unknown;
-};
 type FXErrRuntimeOptions = {
     kind: FXErrKind;
     msg: string;
@@ -52,11 +47,6 @@ export declare function errFX<T extends object = Record<string, unknown>>(opts:
 export declare function errRequired<T extends object = Record<string, unknown>>(opts: RequiredFXErrOptions<T>): FXErr;
 export declare function errValidation<T extends object = Record<string, unknown>>(opts: ValidationFXErrOptions<T>): FXErr;
 export declare function errResolveFailed<T extends object = Record<string, unknown>>(opts: ResolveFailedFXErrOptions<T>): FXErr;
-export declare function errUsernameResolveFailed<T extends object = Record<string, unknown>>(field?: FieldOf<T>): FXErr;
-export declare function errVideoTokenMintFailed(): FXErr;
-export declare function errUsernameInvalid<T extends object = Record<string, unknown>>(opts: UsernameInvalidFXErrOptions<T>): FXErr;
-export declare function errPhoneRequired<T extends object = Record<string, unknown>>(field: FieldOf<T>): FXErr;
-export declare function errPhoneCodeRequired<T extends object = Record<string, unknown>>(field: FieldOf<T>): FXErr;
 export declare function errUnknown(cause: unknown): FXErr;
 export declare function isFXErr(err: unknown): err is FXErr;
 export declare function fxErrMessage(err: unknown): string;