@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/services/base/KeyValueDBService.js

@@ -0,0 +1,133 @@
+import { ServiceBase } from "./ServiceBase.js";
+import { delay, yieldMicrotask } from "octagonal-wheels/promises";
+import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "../../common/logger.js";
+import { createInstanceLogFunction } from "../lib/logUtils.js";
+class KeyValueDBService extends ServiceBase {
+  _kvDB;
+  _simpleStore;
+  get simpleStore() {
+    if (!this._simpleStore) {
+      throw new Error("SimpleStore is not initialized yet");
+    }
+    return this._simpleStore;
+  }
+  get kvDB() {
+    if (!this._kvDB) {
+      throw new Error("KeyValueDB is not initialized yet");
+    }
+    return this._kvDB;
+  }
+  databaseEvents;
+  vault;
+  appLifecycle;
+  openKeyValueDatabase;
+  _log = createInstanceLogFunction("KeyValueDBService");
+  async _everyOnResetDatabase(any) {
+    try {
+      const kvDBKey = "queued-files";
+      await this._kvDB?.del(kvDBKey);
+      await this._kvDB?.destroy();
+      await yieldMicrotask();
+      this._kvDB = await this.openKeyValueDatabase(this.vault.getVaultName() + "-livesync-kv");
+      await delay(100);
+    } catch (e) {
+      this._kvDB = void 0;
+      this._log("Failed to reset KeyValueDB", LOG_LEVEL_NOTICE);
+      this._log(e, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+    return true;
+  }
+  async tryCloseKvDB() {
+    try {
+      await this._kvDB?.close();
+      return true;
+    } catch (e) {
+      this._log("Failed to close KeyValueDB", LOG_LEVEL_VERBOSE);
+      this._log(e);
+      return false;
+    }
+  }
+  async openKeyValueDB() {
+    await delay(10);
+    try {
+      await this.tryCloseKvDB();
+      await delay(10);
+      await yieldMicrotask();
+      this._kvDB = await this.openKeyValueDatabase(this.vault.getVaultName() + "-livesync-kv");
+      await yieldMicrotask();
+      await delay(100);
+    } catch (e) {
+      this._kvDB = void 0;
+      this._log("Failed to open KeyValueDB", LOG_LEVEL_NOTICE);
+      this._log(e, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+    return true;
+  }
+  // Called when another database; LiveSyncLocalDB, is being unloaded.
+  // We need to close our KeyValueDB to avoid IndexedDB locking issues.
+  async _onOtherDatabaseUnload() {
+    if (this._kvDB) await this.tryCloseKvDB();
+    return Promise.resolve(true);
+  }
+  // Also, Called when another database; LiveSyncLocalDB, is being closed.
+  // We need to close our KeyValueDB to avoid IndexedDB locking issues.
+  async _onOtherDatabaseClose() {
+    if (this._kvDB) await this.tryCloseKvDB();
+    return Promise.resolve(true);
+  }
+  _everyOnInitializeDatabase(any) {
+    return this.openKeyValueDB();
+  }
+  async _everyOnloadAfterLoadSettings() {
+    if (!await this.openKeyValueDB()) {
+      return false;
+    }
+    this._simpleStore = this.openSimpleStore("os");
+    return Promise.resolve(true);
+  }
+  constructor(context, dependencies) {
+    super(context);
+    this.databaseEvents = dependencies.databaseEvents;
+    this.vault = dependencies.vault;
+    this.appLifecycle = dependencies.appLifecycle;
+    this.openKeyValueDatabase = dependencies.openKeyValueDatabase;
+    this.databaseEvents.onResetDatabase.addHandler(this._everyOnResetDatabase.bind(this));
+    this.appLifecycle.onSettingLoaded.addHandler(this._everyOnloadAfterLoadSettings.bind(this));
+    this.databaseEvents.onDatabaseInitialisation.addHandler(this._everyOnInitializeDatabase.bind(this));
+    this.databaseEvents.onUnloadDatabase.addHandler(this._onOtherDatabaseUnload.bind(this));
+    this.databaseEvents.onCloseDatabase.addHandler(this._onOtherDatabaseClose.bind(this));
+  }
+  openSimpleStore(kind) {
+    const getDB = () => {
+      if (!this._kvDB) {
+        throw new Error("KeyValueDB is not initialized yet");
+      }
+      return this._kvDB;
+    };
+    const prefix = `${kind}-`;
+    return {
+      get: async (key) => {
+        return await getDB().get(`${prefix}${key}`);
+      },
+      set: async (key, value) => {
+        await getDB().set(`${prefix}${key}`, value);
+      },
+      delete: async (key) => {
+        await getDB().del(`${prefix}${key}`);
+      },
+      keys: async (from, to, count) => {
+        const ret = await getDB().keys(
+          IDBKeyRange.bound(`${prefix}${from || ""}`, `${prefix}${to || ""}`),
+          count
+        );
+        return ret.map((e) => (typeof e === "string" ? e : JSON.stringify(e)).toString()).filter((e) => e.startsWith(prefix)).map((e) => e.substring(prefix.length));
+      },
+      db: Promise.resolve(getDB())
+    };
+  }
+}
+export {
+  KeyValueDBService
+};

package/dist/services/base/MessageTranslator.d.ts

@@ -0,0 +1,6 @@
+/** Placeholder values substituted by a host translator. */
+export type TranslationParameters = Readonly<Record<string, string>>;
+/** A message translator supplied by the host for one service context. */
+export type MessageTranslator = <TKey extends string>(key: TKey, params?: TranslationParameters) => string;
+/** Default translator for headless clients which returns the message key unchanged. */
+export declare const passthroughMessageTranslator: MessageTranslator;

package/dist/services/base/MessageTranslator.js

@@ -0,0 +1,4 @@
+const passthroughMessageTranslator = (key) => key;
+export {
+  passthroughMessageTranslator
+};

package/dist/services/base/PathService.d.ts

@@ -0,0 +1,38 @@
+import type { DocumentID, EntryHasPath, FilePathWithPrefix, FilePath, AnyEntry, UXFileInfo, UXFileInfoStub } from "../../common/types.js";
+import type { IPathService, ISettingService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+import type { BASE_IS_NEW, EVEN, TARGET_IS_NEW } from "../../common/models/shared.const.symbols.js";
+export interface PathServiceDependencies {
+    settingService: ISettingService;
+}
+/**
+ * The PathService provides methods for converting between file paths and document IDs.
+ * This class would be migrated to the new logic later.
+ */
+export declare abstract class PathService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IPathService {
+    protected settingService: ISettingService;
+    protected abstract normalizePath(path: string): string;
+    get settings(): import("../../common/types.js").ObsidianLiveSyncSettings;
+    constructor(context: T, dependencies: PathServiceDependencies);
+    private _id2path;
+    private _path2id;
+    /**
+     * Convert a document ID or entry to a virtual file path.
+     * @param id A document ID. Nowadays, it is mostly not the same as the file path.
+     * If the document has `_` prefixed, saved as `/_`.
+     * @param entry An entry object. If provided, it can be used to get the path directly.
+     * @param stripPrefix Whether to strip the prefix from the path.
+     */
+    id2path(id: DocumentID, entry?: EntryHasPath, stripPrefix?: boolean): FilePathWithPrefix;
+    /**
+     * Convert a virtual file path to a document ID (with prefix if any).
+     * @param filename A file path with or without prefix.
+     * @param prefix The prefix to use for the document ID.
+     */
+    path2id(filename: FilePathWithPrefix | FilePath, prefix?: string): Promise<DocumentID>;
+    getPath(entry: AnyEntry): FilePathWithPrefix;
+    abstract markChangesAreSame(old: UXFileInfo | AnyEntry | FilePathWithPrefix, newMtime: number, oldMtime: number): boolean | undefined;
+    abstract unmarkChanges(file: AnyEntry | FilePathWithPrefix | UXFileInfoStub): void;
+    abstract compareFileFreshness(baseFile: UXFileInfoStub | AnyEntry | undefined, checkTarget: UXFileInfo | AnyEntry | undefined): typeof BASE_IS_NEW | typeof TARGET_IS_NEW | typeof EVEN;
+    abstract isMarkedAsSameChanges(file: UXFileInfoStub | AnyEntry | FilePathWithPrefix, mtimes: number[]): undefined | typeof EVEN;
+}

package/dist/services/base/PathService.js

@@ -0,0 +1,66 @@
+import { ServiceBase } from "./ServiceBase.js";
+import { addPrefix, id2path_base, path2id_base } from "../../string_and_binary/path.js";
+import { isInternalMetadata, stripInternalMetadataPrefix } from "../../common/typeUtils.js";
+class PathService extends ServiceBase {
+  settingService;
+  get settings() {
+    return this.settingService.currentSettings();
+  }
+  constructor(context, dependencies) {
+    super(context);
+    this.settingService = dependencies.settingService;
+  }
+  _id2path(id, entry) {
+    const filename = id2path_base(id, entry);
+    const temp = filename.split(":");
+    const path = temp.pop();
+    const normalizedPath = this.normalizePath(path);
+    temp.push(normalizedPath);
+    const fixedPath = temp.join(":");
+    return fixedPath;
+  }
+  async _path2id(filename, obfuscatePassphrase, caseInsensitive) {
+    const temp = filename.split(":");
+    const path = temp.pop();
+    const normalizedPath = this.normalizePath(path);
+    temp.push(normalizedPath);
+    const fixedPath = temp.join(":");
+    const out = await path2id_base(fixedPath, obfuscatePassphrase, caseInsensitive);
+    return out;
+  }
+  /**
+   * Convert a document ID or entry to a virtual file path.
+   * @param id A document ID. Nowadays, it is mostly not the same as the file path.
+   * If the document has `_` prefixed, saved as `/_`.
+   * @param entry An entry object. If provided, it can be used to get the path directly.
+   * @param stripPrefix Whether to strip the prefix from the path.
+   */
+  id2path(id, entry, stripPrefix) {
+    const tempId = this._id2path(id, entry);
+    if (stripPrefix && isInternalMetadata(tempId)) {
+      const out = stripInternalMetadataPrefix(tempId);
+      return out;
+    }
+    return tempId;
+  }
+  /**
+   * Convert a virtual file path to a document ID (with prefix if any).
+   * @param filename A file path with or without prefix.
+   * @param prefix The prefix to use for the document ID.
+   */
+  async path2id(filename, prefix) {
+    const destPath = addPrefix(filename, prefix ?? "");
+    const setting = this.settings;
+    return await this._path2id(
+      destPath,
+      setting.usePathObfuscation ? setting.passphrase : "",
+      !setting.handleFilenameCaseSensitive
+    );
+  }
+  getPath(entry) {
+    return this.id2path(entry._id, entry);
+  }
+}
+export {
+  PathService
+};

package/dist/services/base/RemoteService.d.ts

@@ -0,0 +1,61 @@
+import type { CouchDBCredentials, EntryDoc } from "../../common/types.js";
+import type { IRemoteService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+import { type LOG_LEVEL } from "../../common/types.js";
+import { AuthorizationHeaderGenerator } from "../../replication/httplib.js";
+import type { APIService } from "./APIService.js";
+import type { AppLifecycleService } from "./AppLifecycleService.js";
+import type { SettingService } from "./SettingService.js";
+import { UnresolvedErrorManager } from "./UnresolvedErrorManager.js";
+import { type LogFunction } from "../lib/logUtils.js";
+import type { PouchDBConstructor } from "../../pouchdb/PouchDBConstructor.js";
+export interface RemoteServiceDependencies {
+    /** PouchDB with the HTTP adapter required by the host runtime already registered. */
+    pouchDB: PouchDBConstructor;
+    APIService: APIService;
+    appLifecycle: AppLifecycleService;
+    setting: SettingService;
+}
+declare const FetchMethod: {
+    readonly webCompat: 0;
+    readonly native: 1;
+};
+type FetchMethod = (typeof FetchMethod)[keyof typeof FetchMethod];
+/**
+ * The RemoteService provides methods for interacting with the remote database.
+ */
+export declare abstract class RemoteService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IRemoteService {
+    /**
+     * Connect to the remote database with the provided settings.
+     * @param uri  The URI of the remote database.
+     * @param auth  The authentication credentials for the remote database.
+     * @param disableRequestURI  Whether to disable the request URI.
+     * @param passphrase  The passphrase for the remote database.
+     * @param useDynamicIterationCount  Whether to use dynamic iteration count.
+     * @param performSetup  Whether to perform setup.
+     * @param skipInfo  Whether to skip information retrieval.
+     * @param compression  Whether to enable compression.
+     * @param customHeaders  Custom headers to include in the request.
+     * @param useRequestAPI  Whether to use the request API.
+     * @param getPBKDF2Salt  Function to retrieve the PBKDF2 salt.
+     * Note that this function is used for CouchDB and compatible only.
+     */
+    protected _log: LogFunction;
+    protected _authHeader: AuthorizationHeaderGenerator;
+    protected _APIService: APIService;
+    protected _appLifecycleService: AppLifecycleService;
+    protected _settingService: SettingService;
+    protected _unresolvedErrors: UnresolvedErrorManager;
+    protected _pouchDB: PouchDBConstructor;
+    protected last_successful_post: boolean;
+    get hadLastPostFailedBySize(): boolean;
+    constructor(context: T, dependencies: RemoteServiceDependencies);
+    showError(msg: string, max_log_level?: LOG_LEVEL): void;
+    clearErrors(): void;
+    performFetch(req: string | Request, opts?: RequestInit, fetchMethod?: FetchMethod): Promise<Response>;
+    connect(uri: string, auth: CouchDBCredentials, disableRequestURI: boolean, passphrase: string | false, useDynamicIterationCount: boolean, performSetup: boolean, skipInfo: boolean, compression: boolean, customHeaders: Record<string, string>, useRequestAPI: boolean, getPBKDF2Salt: () => Promise<Uint8Array<ArrayBuffer>>): Promise<string | {
+        db: PouchDB.Database<EntryDoc>;
+        info: PouchDB.Core.DatabaseInfo;
+    }>;
+}
+export {};

package/dist/services/base/RemoteService.js

@@ -0,0 +1,212 @@
+import { ServiceBase } from "./ServiceBase.js";
+import {
+  LOG_LEVEL_DEBUG,
+  LOG_LEVEL_INFO,
+  LOG_LEVEL_NOTICE,
+  LOG_LEVEL_VERBOSE
+} from "../../common/types.js";
+import { replicationFilter } from "../../pouchdb/compress.js";
+import { disableEncryption, enableEncryption } from "../../pouchdb/encryption.js";
+import { isCloudantURI, isValidRemoteCouchDBURI } from "../../pouchdb/utils_couchdb.js";
+import { AuthorizationHeaderGenerator } from "../../replication/httplib.js";
+import { UnresolvedErrorManager } from "./UnresolvedErrorManager.js";
+import { createInstanceLogFunction, MARK_LOG_NETWORK_ERROR } from "../lib/logUtils.js";
+import { runWithTrackedPhysicalRequest } from "../lib/remoteActivity.js";
+import { LiveSyncError } from "../../common/LSError.js";
+const FetchMethod = {
+  webCompat: 0,
+  native: 1
+};
+class RemoteService extends ServiceBase {
+  /**
+   * Connect to the remote database with the provided settings.
+   * @param uri  The URI of the remote database.
+   * @param auth  The authentication credentials for the remote database.
+   * @param disableRequestURI  Whether to disable the request URI.
+   * @param passphrase  The passphrase for the remote database.
+   * @param useDynamicIterationCount  Whether to use dynamic iteration count.
+   * @param performSetup  Whether to perform setup.
+   * @param skipInfo  Whether to skip information retrieval.
+   * @param compression  Whether to enable compression.
+   * @param customHeaders  Custom headers to include in the request.
+   * @param useRequestAPI  Whether to use the request API.
+   * @param getPBKDF2Salt  Function to retrieve the PBKDF2 salt.
+   * Note that this function is used for CouchDB and compatible only.
+   */
+  _log;
+  _authHeader = new AuthorizationHeaderGenerator();
+  _APIService;
+  _appLifecycleService;
+  _settingService;
+  _unresolvedErrors;
+  _pouchDB;
+  last_successful_post = false;
+  get hadLastPostFailedBySize() {
+    return !this.last_successful_post;
+  }
+  constructor(context, dependencies) {
+    super(context);
+    this._pouchDB = dependencies.pouchDB;
+    this._APIService = dependencies.APIService;
+    this._appLifecycleService = dependencies.appLifecycle;
+    this._settingService = dependencies.setting;
+    this._log = createInstanceLogFunction("RemoteService", dependencies.APIService);
+    this._unresolvedErrors = new UnresolvedErrorManager(this._appLifecycleService, this.context.events);
+  }
+  showError(msg, max_log_level = LOG_LEVEL_NOTICE) {
+    this._unresolvedErrors.showError(msg, max_log_level);
+  }
+  clearErrors() {
+    this._unresolvedErrors.clearErrors();
+  }
+  async performFetch(req, opts, fetchMethod = FetchMethod.webCompat) {
+    const useNativeFetch = fetchMethod === FetchMethod.native;
+    const fetchFunction = useNativeFetch ? this._APIService.nativeFetch.bind(this._APIService) : this._APIService.webCompatFetch.bind(this._APIService);
+    return await runWithTrackedPhysicalRequest(this._APIService, async () => {
+      const response = await fetchFunction(req, opts);
+      const method = opts?.method ?? "GET";
+      if (method == "POST" || method == "PUT") {
+        this.last_successful_post = response.ok;
+      } else {
+        this.last_successful_post = true;
+      }
+      const url = new URL(typeof req === "string" ? req : req.url);
+      const localURL = `${url.protocol}//${url.host}${url.pathname}`;
+      this._log(`[REQ] (${method}) ${localURL} -> ${response.status}`, LOG_LEVEL_DEBUG);
+      if (Math.floor(response.status / 100) !== 2) {
+        if (response.status == 404) {
+          if (method === "GET" && url.pathname.indexOf("/_local/") === -1) {
+            this._log(
+              `Just checkpoint or some server information has been missing. The 404 error shown above is not an error.`,
+              LOG_LEVEL_VERBOSE
+            );
+          }
+        } else {
+          const r = response.clone();
+          this._log(
+            `The request may have failed. The reason sent by the server: ${r.status}: ${r.statusText}`,
+            LOG_LEVEL_NOTICE
+          );
+          try {
+            const result = await r.text();
+            this._log(result, LOG_LEVEL_VERBOSE);
+          } catch (_) {
+            this._log("Could not fetch response body", LOG_LEVEL_VERBOSE);
+            this._log(_, LOG_LEVEL_VERBOSE);
+          }
+        }
+      } else {
+        this.clearErrors();
+      }
+      return response;
+    });
+  }
+  async connect(uri, auth, disableRequestURI, passphrase, useDynamicIterationCount, performSetup, skipInfo, compression, customHeaders, useRequestAPI, getPBKDF2Salt) {
+    if (!isValidRemoteCouchDBURI(uri)) return "Remote URI is not valid";
+    if (uri.toLowerCase() != uri) return "Remote URI and database name could not contain capital letters.";
+    if (uri.indexOf(" ") !== -1) return "Remote URI and database name could not contain spaces.";
+    if (!this._APIService.isOnline) {
+      return "Network is offline";
+    }
+    const conf = {
+      adapter: "http",
+      auth: "username" in auth ? auth : void 0,
+      skip_setup: !performSetup,
+      fetch: async (requestSrc, opts) => {
+        const url = new URL(typeof requestSrc === "string" ? requestSrc : requestSrc.url);
+        const authHeader = await this._authHeader.getAuthorizationHeader(auth);
+        let size = "";
+        const localURL = url.toString().substring(uri.length);
+        const method = opts?.method ?? "GET";
+        if (opts?.body) {
+          const bodyLength = typeof opts.body === "string" ? opts.body.length : JSON.stringify(opts.body).length;
+          const opts_length = isNaN(bodyLength) ? 0 : bodyLength;
+          if (opts_length > 1e3 * 1e3 * 10) {
+            if (isCloudantURI(uri)) {
+              this.last_successful_post = false;
+              this._log("This request should fail on IBM Cloudant.", LOG_LEVEL_VERBOSE);
+              throw new Error("This request should fail on IBM Cloudant.");
+            }
+          }
+          size = ` (${opts_length})`;
+        }
+        try {
+          const headers = new Headers(opts?.headers);
+          if (customHeaders) {
+            for (const [key, value] of Object.entries(customHeaders)) {
+              if (key && value) {
+                headers.append(key, value);
+              }
+            }
+          }
+          if (!("username" in auth)) {
+            headers.append("authorization", authHeader);
+          }
+          try {
+            const response = await this.performFetch(
+              requestSrc,
+              { ...opts, headers },
+              useRequestAPI ? FetchMethod.native : FetchMethod.webCompat
+            );
+            return response;
+          } catch (ex) {
+            if (ex instanceof TypeError) {
+              if (useRequestAPI) {
+                this._log("Failed to request by API.");
+                throw ex;
+              }
+              this._log(
+                "Failed to fetch by native fetch API. Trying to fetch by API to get more information."
+              );
+              const resp2 = await this.performFetch(requestSrc, { ...opts, headers }, FetchMethod.native);
+              if (resp2.status / 100 == 2) {
+                this.showError(
+                  "The request was successful by API. But the native fetch API failed! Please check CORS settings on the remote database!. While this condition, you cannot enable LiveSync",
+                  LOG_LEVEL_NOTICE
+                );
+                return resp2;
+              }
+              const r2 = resp2.clone();
+              const msg = await r2.text();
+              this.showError(`Failed to fetch by API. ${resp2.status}: ${msg}`, LOG_LEVEL_NOTICE);
+              return resp2;
+            }
+            throw ex;
+          }
+        } catch (ex) {
+          this._log(`HTTP:${method}${size} to:${localURL} -> failed`, LOG_LEVEL_VERBOSE);
+          const msg = ex instanceof Error ? `${ex?.name}:${ex?.message}` : ex?.toString();
+          this.showError(`${MARK_LOG_NETWORK_ERROR}Network Error: Failed to fetch: ${msg}`, LOG_LEVEL_INFO);
+          this._log(ex, LOG_LEVEL_VERBOSE);
+          if (url.toString().indexOf("_bulk_docs") !== -1) {
+            this.last_successful_post = false;
+          }
+          this._log(ex);
+          throw ex;
+        }
+      }
+    };
+    const setting = this._settingService.currentSettings();
+    const db = new this._pouchDB(uri, conf);
+    replicationFilter(db, compression);
+    disableEncryption();
+    if (passphrase !== "false" && typeof passphrase === "string") {
+      enableEncryption(db, passphrase, useDynamicIterationCount, false, getPBKDF2Salt, setting.E2EEAlgorithm);
+    }
+    if (skipInfo) {
+      return { db, info: { db_name: "", doc_count: 0, update_seq: "" } };
+    }
+    try {
+      const info = await db.info();
+      return { db, info };
+    } catch (ex) {
+      const exMsg = ex instanceof Error ? ex : LiveSyncError.fromError(ex);
+      const msg = `${exMsg.name}:${exMsg.message}`;
+      this._log(ex, LOG_LEVEL_VERBOSE);
+      return msg;
+    }
+  }
+}
+export {
+  RemoteService
+};

package/dist/services/base/ReplicationService.d.ts

@@ -0,0 +1,92 @@
+import { type LOG_LEVEL } from "../../common/types.js";
+import type { IAPIService, IDatabaseService, IFileProcessingService, IReplicationService, IReplicatorService, ISettingService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+import { type LogFunction } from "../lib/logUtils.js";
+import type { LiveSyncAbstractReplicator } from "../../replication/LiveSyncAbstractReplicator.js";
+import type { AppLifecycleService } from "./AppLifecycleService.js";
+export interface ReplicationServiceDependencies {
+    APIService: IAPIService;
+    settingService: ISettingService;
+    appLifecycleService: AppLifecycleService;
+    databaseService: IDatabaseService;
+    replicatorService: IReplicatorService;
+    fileProcessingService: IFileProcessingService;
+}
+/**
+ * The ReplicationService provides methods for managing replication processes.
+ */
+export declare abstract class ReplicationService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IReplicationService {
+    private _unresolvedErrorManager;
+    showError(msg: string, max_log_level?: LOG_LEVEL): void;
+    clearErrors(): void;
+    _log: LogFunction;
+    settingService: ISettingService;
+    appLifecycleService: AppLifecycleService;
+    replicatorService: IReplicatorService;
+    APIService: IAPIService;
+    fileProcessing: IFileProcessingService;
+    databaseService: IDatabaseService;
+    constructor(context: T, dependencies: ReplicationServiceDependencies);
+    /**
+     * Process a synchronisation result document.
+     */
+    readonly processSynchroniseResult: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(doc: import("../../common/types.js").MetaEntry) => Promise<boolean>>;
+    /**
+     * Process a synchronisation result document for optional entries i.e., hidden files.
+     */
+    readonly processOptionalSynchroniseResult: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(doc: import("../../common/types.js").LoadedEntry) => Promise<boolean>>;
+    /**
+     * Process an array of synchronisation result documents.
+     * @param docs An array of documents to parse and handle.
+     */
+    readonly parseSynchroniseResult: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(docs: Array<PouchDB.Core.ExistingDocument<import("../../common/types.js").EntryDoc>>) => Promise<boolean>>;
+    /**
+     * Process a virtual document (e.g., for customisation sync).
+     */
+    readonly processVirtualDocument: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(docs: PouchDB.Core.ExistingDocument<import("../../common/types.js").EntryDoc>) => Promise<boolean>>;
+    /**
+     * An event triggered before starting replication.
+     */
+    readonly onBeforeReplicate: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(showMessage: boolean) => Promise<boolean>>;
+    /**
+     *
+     */
+    readonly onCheckReplicationReady: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(showMessage: boolean) => Promise<boolean>>;
+    /**
+     *  Check if the replication is ready to start.
+     * @param showMessage Whether to show messages to the user.
+     */
+    isReplicationReady(showMessage?: boolean): Promise<boolean>;
+    onReplicationFailed: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(showMessage?: boolean) => Promise<boolean>>;
+    private performReplicationRequest;
+    /**
+     * Perform replication and handle a failed result.
+     * @param showMessage Whether to show replication progress messages.
+     */
+    performReplication(showMessage?: boolean): Promise<boolean | void>;
+    /**
+     * Start the replication process.
+     * @param showMessage Whether to show messages to the user.
+     */
+    replicate(showMessage?: boolean): Promise<boolean | void>;
+    previousReplicated: number;
+    /**
+     * Start the replication process triggered by an event (e.g., file change).
+     * @param showMessage Whether to show messages to the user.
+     */
+    replicateByEvent(showMessage?: boolean): Promise<boolean | void>;
+    /**
+     * Check if there is a connection failure with the remote database.
+     */
+    readonly checkConnectionFailure: import("../lib/HandlerUtils.js").MultipleHandlerFunction<() => Promise<boolean | "CHECKAGAIN" | undefined>, unknown>;
+    databaseQueueCount: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
+    storageApplyingCount: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
+    replicationResultCount: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
+    getActiveReplicatorFor(usage: string): false | LiveSyncAbstractReplicator;
+    replicateAllToRemote(showingNotice?: boolean, sendChunksInBulkDisabled?: boolean): Promise<boolean>;
+    replicateAllFromRemote(showingNotice?: boolean): Promise<boolean>;
+    private _getReplicatorAndPerform;
+    markLocked(lockByClean?: boolean): Promise<void>;
+    markUnlocked(): Promise<void>;
+    markResolved(): Promise<void>;
+}