@actual-app/api 25.3.0 → 25.4.0-alpha.0

package/@types/loot-core/client/store/index.d.ts

@@ -0,0 +1,133 @@
+export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    account: {
+        failedAccounts: {
+            [key: import("../../types/models").AccountEntity["id"]]: {
+                type: string;
+                code: string;
+            };
+        };
+        accountsSyncing: Array<import("../../types/models").AccountEntity["id"]>;
+    };
+    app: {
+        loadingText: string | null;
+        updateInfo: {
+            version: string;
+            releaseDate: string;
+            releaseNotes: string;
+        } | null;
+        showUpdateNotification: boolean;
+        managerHasInitialized: boolean;
+    };
+    budgets: {
+        budgets: import("../../types/budget").Budget[];
+        remoteFiles: import("../../server/cloud-storage").RemoteFile[] | null;
+        allFiles: import("../../types/file").File[] | null;
+    };
+    modals: {
+        modalStack: import("../modals/modalsSlice").Modal[];
+        isHidden: boolean;
+    };
+    notifications: {
+        notifications: import("../notifications/notificationsSlice").NotificationWithId[];
+        inset?: {
+            bottom?: number;
+            top?: number;
+            right?: number;
+            left?: number;
+        };
+    };
+    prefs: {
+        local: import("../../types/prefs").MetadataPrefs;
+        global: import("../../types/prefs").GlobalPrefs;
+        synced: import("../../types/prefs").SyncedPrefs;
+    };
+    queries: {
+        newTransactions: Array<import("../../types/models").TransactionEntity["id"]>;
+        matchedTransactions: Array<import("../../types/models").TransactionEntity["id"]>;
+        lastTransaction: import("../../types/models").TransactionEntity | null;
+        updatedAccounts: Array<import("../../types/models").AccountEntity["id"]>;
+        accounts: import("../../types/models").AccountEntity[];
+        accountsLoaded: boolean;
+        categories: {
+            grouped: import("../../types/models").CategoryGroupEntity[];
+            list: import("../../types/models").CategoryEntity[];
+        };
+        categoriesLoaded: boolean;
+        commonPayeesLoaded: boolean;
+        commonPayees: import("../../types/models").PayeeEntity[];
+        payees: import("../../types/models").PayeeEntity[];
+        payeesLoaded: boolean;
+    };
+    user: {
+        data: Awaited<ReturnType<import("../../types/handlers").Handlers["subscribe-get-user"]>>;
+    };
+}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: ((action: import("redux").Action<"listenerMiddleware/add">) => import("@reduxjs/toolkit").UnsubscribeListener) & import("redux-thunk").ThunkDispatch<{
+        account: {
+            failedAccounts: {
+                [key: import("../../types/models").AccountEntity["id"]]: {
+                    type: string;
+                    code: string;
+                };
+            };
+            accountsSyncing: Array<import("../../types/models").AccountEntity["id"]>;
+        };
+        app: {
+            loadingText: string | null;
+            updateInfo: {
+                version: string;
+                releaseDate: string;
+                releaseNotes: string;
+            } | null;
+            showUpdateNotification: boolean;
+            managerHasInitialized: boolean;
+        };
+        budgets: {
+            budgets: import("../../types/budget").Budget[];
+            remoteFiles: import("../../server/cloud-storage").RemoteFile[] | null;
+            allFiles: import("../../types/file").File[] | null;
+        };
+        modals: {
+            modalStack: import("../modals/modalsSlice").Modal[];
+            isHidden: boolean;
+        };
+        notifications: {
+            notifications: import("../notifications/notificationsSlice").NotificationWithId[];
+            inset?: {
+                bottom?: number;
+                top?: number;
+                right?: number;
+                left?: number;
+            };
+        };
+        prefs: {
+            local: import("../../types/prefs").MetadataPrefs;
+            global: import("../../types/prefs").GlobalPrefs;
+            synced: import("../../types/prefs").SyncedPrefs;
+        };
+        queries: {
+            newTransactions: Array<import("../../types/models").TransactionEntity["id"]>;
+            matchedTransactions: Array<import("../../types/models").TransactionEntity["id"]>;
+            lastTransaction: import("../../types/models").TransactionEntity | null;
+            updatedAccounts: Array<import("../../types/models").AccountEntity["id"]>;
+            accounts: import("../../types/models").AccountEntity[];
+            accountsLoaded: boolean;
+            categories: {
+                grouped: import("../../types/models").CategoryGroupEntity[];
+                list: import("../../types/models").CategoryEntity[];
+            };
+            categoriesLoaded: boolean;
+            commonPayeesLoaded: boolean;
+            commonPayees: import("../../types/models").PayeeEntity[];
+            payees: import("../../types/models").PayeeEntity[];
+            payeesLoaded: boolean;
+        };
+        user: {
+            data: Awaited<ReturnType<import("../../types/handlers").Handlers["subscribe-get-user"]>>;
+        };
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+export type AppStore = typeof store;
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;
+export type GetRootState = typeof store.getState;

package/@types/loot-core/client/users/usersSlice.d.ts

@@ -0,0 +1,105 @@
+import { type Handlers } from '../../types/handlers';
+export declare const getUserData: import("@reduxjs/toolkit").AsyncThunk<{
+    offline: boolean;
+    userName?: undefined;
+    permission?: undefined;
+    userId?: undefined;
+    displayName?: undefined;
+    loginMethod?: undefined;
+    tokenExpired?: undefined;
+} | {
+    offline: boolean;
+    userName: any;
+    permission: any;
+    userId: any;
+    displayName: any;
+    loginMethod: any;
+    tokenExpired: boolean;
+}, void, {
+    state: import("../store").RootState;
+    dispatch: import("../store").AppDispatch;
+    extra?: unknown;
+    rejectValue?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const loggedIn: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+    state: import("../store").RootState;
+    dispatch: import("../store").AppDispatch;
+    extra?: unknown;
+    rejectValue?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const signOut: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+    state: import("../store").RootState;
+    dispatch: import("../store").AppDispatch;
+    extra?: unknown;
+    rejectValue?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+type UsersState = {
+    data: Awaited<ReturnType<Handlers['subscribe-get-user']>>;
+};
+type GetUserDataPayload = {
+    data: UsersState['data'];
+};
+export declare const name: "user", reducer: import("redux").Reducer<UsersState>, getInitialState: () => UsersState;
+export declare const actions: {
+    getUserData: import("@reduxjs/toolkit").AsyncThunk<{
+        offline: boolean;
+        userName?: undefined;
+        permission?: undefined;
+        userId?: undefined;
+        displayName?: undefined;
+        loginMethod?: undefined;
+        tokenExpired?: undefined;
+    } | {
+        offline: boolean;
+        userName: any;
+        permission: any;
+        userId: any;
+        displayName: any;
+        loginMethod: any;
+        tokenExpired: boolean;
+    }, void, {
+        state: import("../store").RootState;
+        dispatch: import("../store").AppDispatch;
+        extra?: unknown;
+        rejectValue?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    loggedIn: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+        state: import("../store").RootState;
+        dispatch: import("../store").AppDispatch;
+        extra?: unknown;
+        rejectValue?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    signOut: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+        state: import("../store").RootState;
+        dispatch: import("../store").AppDispatch;
+        extra?: unknown;
+        rejectValue?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    loadUserData: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<GetUserDataPayload, "user/loadUserData">;
+};
+export declare const loadUserData: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<GetUserDataPayload, "user/loadUserData">;
+export {};

package/@types/loot-core/mocks/index.d.ts

@@ -1,7 +1,10 @@
-import type { AccountEntity, CategoryEntity, CategoryGroupEntity, NewCategoryGroupEntity, TransactionEntity } from '../types/models';
+import type { AccountEntity, CategoryEntity, CategoryGroupEntity, TransactionEntity } from '../types/models';
 export declare function generateAccount(name: AccountEntity['name'], isConnected?: boolean, offbudget?: boolean): AccountEntity;
 export declare function generateCategory(name: string, group: string, isIncome?: boolean): CategoryEntity;
 export declare function generateCategoryGroup(name: string, isIncome?: boolean): CategoryGroupEntity;
-export declare function generateCategoryGroups(definition: Partial<NewCategoryGroupEntity>[]): CategoryGroupEntity[];
+export type CategoryGroupDefinition = Omit<CategoryGroupEntity, 'id' | 'categories'> & {
+    categories: Omit<CategoryEntity, 'id' | 'group'>[];
+};
+export declare function generateCategoryGroups(definition: Partial<CategoryGroupDefinition>[]): CategoryGroupEntity[];
 export declare function generateTransaction(data: Partial<TransactionEntity> & Pick<TransactionEntity, 'account'>, splitAmount?: number, showError?: boolean): TransactionEntity[];
 export declare function generateTransactions(count: number, accountId: string, groupId: string, splitAtIndexes?: number[], showError?: boolean): TransactionEntity[];

package/@types/loot-core/platform/client/fetch/index.d.ts

@@ -1,5 +1,4 @@
 import type { Handlers } from '../../../types/handlers';
-import type { CategoryGroupEntity } from '../../../types/models';
 import type { ServerEvents } from '../../../types/server-events';
 
 export function init(socketName: string): Promise<unknown>;
@@ -45,15 +44,7 @@ export function unlisten(name: string): void;
 export type Unlisten = typeof unlisten;
 
 /** Mock functions */
-export function initServer(handlers: {
-  query: (query: { table: string; selectExpressions: unknown }) => Promise<{
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    data: any;
-    dependencies: string[];
-  }>;
-  getCell?: () => { value: number };
-  'get-categories'?: () => { grouped: CategoryGroupEntity[] };
-}): void;
+export function initServer(handlers: Partial<Handlers>): void;
 export type InitServer = typeof initServer;
 
 export function serverPush(name: string, args: unknown): void;

package/@types/loot-core/platform/client/undo/index.d.ts

@@ -1,33 +1,21 @@
-import { OptionlessModal } from '../../../client/state-types/modals';
+import { v4 as uuidv4 } from 'uuid';
+import { Modal } from '../../../client/modals/modalsSlice';
 import { UndoState as ServerUndoState } from '../../../server/undo';
-
-export type UndoState = {
-  url: string | null;
-  // Right now, only the payees page uses this. It's only being set to
-  // `manage-rules` which is an optionless modal. Do we want to also
-  // support modals with options?
-  openModal: OptionlessModal | null;
-  selectedItems: {
-    name: string;
-    items: Set<string>;
-  } | null;
-  undoEvent: ServerUndoState | null;
+type UndoState = {
+    url: string | null;
+    openModal: Modal | null;
+    selectedItems: {
+        name: string;
+        items: Set<string>;
+    } | null;
+    undoEvent: ServerUndoState | null;
 };
-
-export function setUndoState<K extends keyof Omit<UndoState, 'id'>>(
-  name: K,
-  value: UndoState[K],
-): void;
-export type SetUndoState = typeof setUndoState;
-
-export function getUndoState<K extends keyof UndoState>(name: K): UndoState[K];
-export type GetUndoState = typeof getUndoState;
-
-export function getTaggedState(id: string): UndoState | undefined;
-export type GetTaggedState = typeof getTaggedState;
-
-export function snapshot(): string;
-export type Snapshot = typeof snapshot;
-
-export function gc(id: string): void;
-export type Gc = typeof gc;
+type UndoStateWithId = UndoState & {
+    id?: ReturnType<typeof uuidv4>;
+};
+export declare const setUndoState: <K extends keyof Omit<UndoState, "id">>(name: K, value: UndoState[K]) => void;
+export declare const getUndoState: <K extends keyof UndoState>(name: K) => UndoStateWithId[K];
+export declare const getTaggedState: (id: string) => UndoStateWithId;
+export declare const snapshot: () => string;
+export declare const gc: (id: string) => void;
+export {};

package/@types/loot-core/platform/exceptions/index.d.ts

@@ -1,5 +1,2 @@
-export function captureException(exc: Error): void;
-export type CaptureException = typeof captureException;
-
-export function captureBreadcrumb(breadcrumb: unknown): void;
-export type CaptureBreadcrumb = typeof captureBreadcrumb;
+export declare const captureException: (exc: Error) => void;
+export declare const captureBreadcrumb: (crumb: unknown) => void;

package/@types/loot-core/platform/server/asyncStorage/index.d.ts

@@ -13,22 +13,22 @@ export type GetItem = typeof getItem;
 export function setItem<K extends keyof GlobalPrefsJson>(
   key: K,
   value: GlobalPrefsJson[K],
-): void;
+): Promise<void>;
 export type SetItem = typeof setItem;
 
-export function removeItem(key: keyof GlobalPrefsJson): void;
+export function removeItem(key: keyof GlobalPrefsJson): Promise<void>;
 export type RemoveItem = typeof removeItem;
 
-export async function multiGet<K extends readonly (keyof GlobalPrefsJson)[]>(
+export function multiGet<K extends readonly (keyof GlobalPrefsJson)[]>(
   keys: K,
 ): Promise<{ [P in keyof K]: [K[P], GlobalPrefsJson[K[P]]] }>;
 export type MultiGet = typeof multiGet;
 
 export function multiSet<K extends keyof GlobalPrefsJson>(
   keyValues: Array<[K, GlobalPrefsJson[K]]>,
-): void;
+): Promise<void>;
 
 export type MultiSet = typeof multiSet;
 
-export function multiRemove(keys: (keyof GlobalPrefsJson)[]): void;
+export function multiRemove(keys: (keyof GlobalPrefsJson)[]): Promise<void>;
 export type MultiRemove = typeof multiRemove;

package/@types/loot-core/platform/server/connection/index.d.ts

@@ -13,9 +13,6 @@ export function send<K extends keyof ServerEvents>(
 ): void;
 export type Send = typeof send;
 
-export function getEvents(): unknown[];
-export type GetEvents = typeof getEvents;
-
 export function getNumClients(): number;
 export type GetNumClients = typeof getNumClients;
 

package/@types/loot-core/platform/server/fetch/index.d.ts

@@ -1,4 +1 @@
-export function fetch(
-  input: RequestInfo | URL,
-  options?: unknown,
-): Promise<Response>;
+export declare const fetch: (input: RequestInfo | URL, options?: RequestInit) => Promise<Response>;

package/@types/loot-core/platform/server/indexeddb/index.d.ts

@@ -1,24 +1,15 @@
-export function getDatabase();
-export type GetDatabase = typeof getDatabase;
-
-export function openDatabase();
-export type OpenDatabase = typeof openDatabase;
-
-export function closeDatabase();
-export type CloseDatabase = typeof closeDatabase;
-
-export function getStore(db: IDBDatabase, name: string);
-export type GetStore = typeof getStore;
-
-export function get(
-  store: IDBObjectStore,
-  key: IDBValidKey | IDBKeyRange,
-  mapper?: (v: unknown) => unknown,
-);
-export type Get = typeof get;
-
-export function set(store: IDBObjectStore, value: unknown);
-export type Set = typeof set;
-
-export function del(store: IDBObjectStore, key: IDBValidKey);
-export type Del = typeof del;
+type Data = {
+    filepath: string;
+    contents: string;
+};
+export declare const getStore: (db: IDBDatabase, name: string) => {
+    trans: IDBTransaction;
+    store: IDBObjectStore;
+};
+export declare const get: (store: IDBObjectStore, key: IDBValidKey | IDBKeyRange) => Promise<Data>;
+export declare const set: (store: IDBObjectStore, item: Data) => Promise<unknown>;
+export declare const del: (store: IDBObjectStore, key: string) => Promise<unknown>;
+export declare const getDatabase: () => Promise<IDBDatabase>;
+export declare const openDatabase: () => Promise<IDBDatabase>;
+export declare const closeDatabase: () => void;
+export {};

package/@types/loot-core/platform/server/log/index.d.ts

@@ -1,6 +1,4 @@
-export interface Logger {
-  info(...args: unknown[]): void;
-  warn(...args: unknown[]): void;
-}
-
-export const logger: Logger;
+export declare const logger: {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+};

package/@types/loot-core/server/accounts/app.d.ts

@@ -1,4 +1,5 @@
-import { AccountEntity, CategoryEntity, SyncServerGoCardlessAccount, TransactionEntity, SyncServerSimpleFinAccount } from '../../types/models';
+import { AccountEntity, CategoryEntity, SyncServerGoCardlessAccount, TransactionEntity, SyncServerSimpleFinAccount, SyncServerPluggyAiAccount } from '../../types/models';
+import * as db from '../db';
 import * as bankSync from './sync';
 export type AccountHandlers = {
     'account-update': typeof updateAccount;
@@ -7,6 +8,7 @@ export type AccountHandlers = {
     'account-properties': typeof getAccountProperties;
     'gocardless-accounts-link': typeof linkGoCardlessAccount;
     'simplefin-accounts-link': typeof linkSimpleFinAccount;
+    'pluggyai-accounts-link': typeof linkPluggyAiAccount;
     'account-create': typeof createAccount;
     'account-close': typeof closeAccount;
     'account-reopen': typeof reopenAccount;
@@ -17,7 +19,9 @@ export type AccountHandlers = {
     'gocardless-poll-web-token-stop': typeof stopGoCardlessWebTokenPolling;
     'gocardless-status': typeof goCardlessStatus;
     'simplefin-status': typeof simpleFinStatus;
+    'pluggyai-status': typeof pluggyAiStatus;
     'simplefin-accounts': typeof simpleFinAccounts;
+    'pluggyai-accounts': typeof pluggyAiAccounts;
     'gocardless-get-banks': typeof getGoCardlessBanks;
     'gocardless-create-web-token': typeof createGoCardlessWebToken;
     'accounts-bank-sync': typeof accountsBankSync;
@@ -25,8 +29,11 @@ export type AccountHandlers = {
     'transactions-import': typeof importTransactions;
     'account-unlink': typeof unlinkAccount;
 };
-declare function updateAccount({ id, name }: Pick<AccountEntity, 'id' | 'name'>): Promise<{}>;
-declare function getAccounts(): Promise<any[]>;
+declare function updateAccount({ id, name, last_reconciled, }: Pick<AccountEntity, 'id' | 'name'> & Partial<Pick<AccountEntity, 'last_reconciled'>>): Promise<{}>;
+declare function getAccounts(): Promise<(db.DbAccount & {
+    bankName: db.DbBank["name"];
+    bankId: db.DbBank["id"];
+})[]>;
 declare function getAccountBalance({ id, cutoff, }: {
     id: string;
     cutoff: string | Date;
@@ -48,6 +55,11 @@ declare function linkSimpleFinAccount({ externalAccount, upgradingId, offBudget,
     upgradingId?: AccountEntity['id'] | undefined;
     offBudget?: boolean | undefined;
 }): Promise<string>;
+declare function linkPluggyAiAccount({ externalAccount, upgradingId, offBudget, }: {
+    externalAccount: SyncServerPluggyAiAccount;
+    upgradingId?: AccountEntity['id'] | undefined;
+    offBudget?: boolean | undefined;
+}): Promise<string>;
 declare function createAccount({ name, balance, offBudget, closed, }: {
     name: string;
     balance?: number | undefined;
@@ -65,7 +77,7 @@ declare function reopenAccount({ id }: {
 }): Promise<void>;
 declare function moveAccount({ id, targetId, }: {
     id: AccountEntity['id'];
-    targetId: AccountEntity['id'];
+    targetId: AccountEntity['id'] | null;
 }): Promise<void>;
 declare function setSecret({ name, value, }: {
     name: string;
@@ -80,7 +92,9 @@ declare function pollGoCardlessWebToken({ requisitionId, }: {
 declare function stopGoCardlessWebTokenPolling(): Promise<string>;
 declare function goCardlessStatus(): Promise<any>;
 declare function simpleFinStatus(): Promise<any>;
+declare function pluggyAiStatus(): Promise<any>;
 declare function simpleFinAccounts(): Promise<any>;
+declare function pluggyAiAccounts(): Promise<any>;
 declare function getGoCardlessBanks(country: string): Promise<any>;
 declare function createGoCardlessWebToken({ institutionId, accessValidForDays, }: {
     institutionId: string;
@@ -140,7 +154,7 @@ export declare const app: {
     handlers: AccountHandlers;
     services: (() => () => void)[];
     unlistenServices: (() => void)[];
-    method<Name extends "account-update" | "accounts-get" | "account-balance" | "account-properties" | "gocardless-accounts-link" | "simplefin-accounts-link" | "account-create" | "account-close" | "account-reopen" | "account-move" | "secret-set" | "secret-check" | "gocardless-poll-web-token" | "gocardless-poll-web-token-stop" | "gocardless-status" | "simplefin-status" | "simplefin-accounts" | "gocardless-get-banks" | "gocardless-create-web-token" | "accounts-bank-sync" | "simplefin-batch-sync" | "transactions-import" | "account-unlink">(name: Name, func: AccountHandlers[Name]): void;
+    method<Name extends "account-update" | "accounts-get" | "account-balance" | "account-properties" | "gocardless-accounts-link" | "simplefin-accounts-link" | "pluggyai-accounts-link" | "account-create" | "account-close" | "account-reopen" | "account-move" | "secret-set" | "secret-check" | "gocardless-poll-web-token" | "gocardless-poll-web-token-stop" | "gocardless-status" | "simplefin-status" | "pluggyai-status" | "simplefin-accounts" | "pluggyai-accounts" | "gocardless-get-banks" | "gocardless-create-web-token" | "accounts-bank-sync" | "simplefin-batch-sync" | "transactions-import" | "account-unlink">(name: Name, func: AccountHandlers[Name]): void;
     service(func: () => () => void): void;
     combine(...apps: any[]): void;
     startServices(): void;

package/@types/loot-core/server/accounts/link.d.ts

@@ -1 +1,6 @@
-export declare function findOrCreateBank(institution: any, requisitionId: any): Promise<any>;
+import * as db from '../db';
+export declare function findOrCreateBank(institution: any, requisitionId: any): Promise<Pick<db.DbBank, "id" | "bank_id"> | {
+    id: string;
+    bank_id: any;
+    name: any;
+}>;

package/@types/loot-core/server/admin/app.d.ts

@@ -1,4 +1,15 @@
-import { AdminHandlers } from './types/handlers';
+import { UserAvailable, UserEntity, NewUserAccessEntity } from '../../types/models';
+export type AdminHandlers = {
+    'users-get': typeof getUsers;
+    'user-delete-all': typeof deleteAllUsers;
+    'user-add': typeof addUser;
+    'user-update': typeof updateUser;
+    'access-add': typeof addAccess;
+    'access-delete-all': typeof deleteAllAccess;
+    'access-get-available-users': typeof accessGetAvailableUsers;
+    'transfer-ownership': typeof transferOwnership;
+    'owner-created': typeof ownerCreated;
+};
 export declare const app: {
     events: import("mitt").Emitter<{
         sync: import("../../types/server-events").ServerEvents["sync-event"];
@@ -15,3 +26,45 @@ export declare const app: {
     startServices(): void;
     stopServices(): void;
 };
+declare function getUsers(): Promise<UserEntity[] | {
+    error: string;
+}>;
+declare function deleteAllUsers(ids: Array<UserEntity['id']>): Promise<{
+    someDeletionsFailed: boolean;
+    ids?: number[];
+} | {
+    error: string;
+}>;
+declare function addUser(user: Omit<UserEntity, 'id'>): Promise<{
+    error: string;
+} | {
+    id: string;
+}>;
+declare function updateUser(user: Omit<UserEntity, 'id'>): Promise<{
+    error: string;
+} | {
+    id: string;
+}>;
+declare function addAccess(access: NewUserAccessEntity): Promise<{
+    error?: string;
+} | Record<string, never>>;
+declare function deleteAllAccess({ fileId, ids, }: {
+    fileId: string;
+    ids: string[];
+}): Promise<{
+    someDeletionsFailed: boolean;
+    ids?: number[];
+} | {
+    error: unknown;
+}>;
+declare function accessGetAvailableUsers(fileId: string): Promise<UserAvailable[] | {
+    error: string;
+}>;
+declare function transferOwnership({ fileId, newUserId, }: {
+    fileId: string;
+    newUserId: string;
+}): Promise<{
+    error?: string;
+} | Record<string, never>>;
+declare function ownerCreated(): Promise<boolean>;
+export {};