document-drive 6.0.0-dev.105 → 6.0.0-dev.106

package/dist/index.d.ts

@@ -1,2 +1,1945 @@
-export * from "./src/index.js";
+import { DocumentDriveAction, DocumentDriveDocument, DocumentDriveLocalState, FileNode, FolderNode, LegacyAddFileAction, ListenerCallInfo, ListenerFilter, PullResponderTriggerData, Trigger } from "@powerhousedao/shared/document-drive";
+import * as document_model0 from "document-model";
+import { Action, ActionContext, DocumentModelGlobalState, DocumentModelModule, DocumentOperations, GetDocumentOptions as GetDocumentOptions$1, Operation, PHBaseState, PHDocument, PHDocumentHeader, PHDocumentMeta, Reducer, ReducerOptions, SignalResult } from "@powerhousedao/shared/document-model";
+import { gql } from "graphql-request";
+import * as nanoevents from "nanoevents";
+import { Unsubscribe } from "nanoevents";
+import { pascalCase } from "change-case";
+import { BuildSchemaOptions, GraphQLError, ParseOptions } from "graphql";
+import * as document_drive0 from "document-drive";
+import { AbortTask as AbortTask$1, ActionJob as ActionJob$1, AddOperationOptions as AddOperationOptions$1, BaseDocumentDriveServer as BaseDocumentDriveServer$1, CancelPullLoop as CancelPullLoop$1, CreateDocumentInput as CreateDocumentInput$1, DefaultRemoteDriveInfo as DefaultRemoteDriveInfo$1, DocumentDriveServerConstructor as DocumentDriveServerConstructor$1, DocumentDriveServerMixin as DocumentDriveServerMixin$1, DocumentDriveServerOptions as DocumentDriveServerOptions$1, DocumentGraphQLResult as DocumentGraphQLResult$1, DocumentJob as DocumentJob$1, DocumentModelNotFoundError as DocumentModelNotFoundError$1, DriveEvents as DriveEvents$1, DriveInfo as DriveInfo$1, DriveUpdateErrorHandler as DriveUpdateErrorHandler$1, ErrorStatus as ErrorStatus$1, GetDocumentModelModule as GetDocumentModelModule$1, GetStrandsOptions as GetStrandsOptions$1, GraphQLResult as GraphQLResult$1, HashAlgorithmsLegacy as HashAlgorithmsLegacy$1, IBaseDocumentDriveServer as IBaseDocumentDriveServer$1, IBaseRelationalDbLegacy as IBaseRelationalDbLegacy$1, ICache as ICache$1, ICacheStorage as ICacheStorage$1, ICacheStorageManager as ICacheStorageManager$1, IDefaultDrivesManager as IDefaultDrivesManager$1, IDocumentAdminStorage as IDocumentAdminStorage$1, IDocumentDriveServer as IDocumentDriveServer$1, IDocumentStorage as IDocumentStorage$1, IDriveOperationStorage as IDriveOperationStorage$1, IEventEmitter as IEventEmitter$1, IJob as IJob$1, IJobQueue as IJobQueue$1, IListenerManager as IListenerManager$1, IOperationResult as IOperationResult$1, IProcessorLegacy as IProcessorLegacy$1, IProcessorManagerLegacy as IProcessorManagerLegacy$1, IPullResponderTransmitter as IPullResponderTransmitter$1, IQueue as IQueue$1, IQueueManager as IQueueManager$1, IReadModeDriveServer as IReadModeDriveServer$1, IReadModeDriveService as IReadModeDriveService$1, IRelationalDbLegacy as IRelationalDbLegacy$1, IRelationalDbProcessorLegacy as IRelationalDbProcessorLegacy$1, IRelationalQueryBuilderLegacy as IRelationalQueryBuilderLegacy$1, IServerDelegate as IServerDelegate$1, IServerDelegateDrivesManager as IServerDelegateDrivesManager$1, IStorageUnit as IStorageUnit$1, IStorageUnitFilter as IStorageUnitFilter$1, ISyncUnitMap as ISyncUnitMap$1, ISynchronizationManager as ISynchronizationManager$1, ITransmitter as ITransmitter$1, ITransmitterFactory as ITransmitterFactory$1, InternalTransmitterUpdate as InternalTransmitterUpdate$1, Job as Job$1, JobId as JobId$1, LRUCacheStorageOptions as LRUCacheStorageOptions$1, ListenerManagerOptions as ListenerManagerOptions$1, ListenerRevision as ListenerRevision$1, ListenerRevisionWithError as ListenerRevisionWithError$1, ListenerState as ListenerState$1, ListenerUpdate as ListenerUpdate$1, OperationJob as OperationJob$1, OperationUpdate as OperationUpdate$1, ProcessorFactoryLegacy as ProcessorFactoryLegacy$1, PullResponderTrigger as PullResponderTrigger$1, QueueEvents as QueueEvents$1, ReadDocumentNotFoundError as ReadDocumentNotFoundError$1, ReadDrive as ReadDrive$1, ReadDriveContext as ReadDriveContext$1, ReadDriveNotFoundError as ReadDriveNotFoundError$1, ReadDriveOptions as ReadDriveOptions$1, ReadDriveSlugNotFoundError as ReadDriveSlugNotFoundError$1, RelationalDbProcessorClassLegacy as RelationalDbProcessorClassLegacy$1, RelationalDbProcessorFilterLegacy as RelationalDbProcessorFilterLegacy$1, RelationalDbProcessorLegacy as RelationalDbProcessorLegacy$1, RemoteDriveAccessLevel as RemoteDriveAccessLevel$1, RemoteDriveOptions as RemoteDriveOptions$1, ResolvedStorageUnitFilter as ResolvedStorageUnitFilter$1, RevisionsFilter as RevisionsFilter$1, RunAsap as RunAsap$1, ServerListener as ServerListener$1, SharingType as SharingType$1, StrandUpdate as StrandUpdate$1, StrandUpdateSource as StrandUpdateSource$1, SyncStatus as SyncStatus$1, SyncUnitStatusObject as SyncUnitStatusObject$1, SynchronizationUnit as SynchronizationUnit$1, SynchronizationUnitId as SynchronizationUnitId$1, SynchronizationUnitQuery as SynchronizationUnitQuery$1, Task as Task$1 } from "document-drive";
+import { RedisClientType } from "redis";
+import { IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
+import { ProcessorApp } from "@powerhousedao/shared/processors";
+import { Kysely, QueryCreator } from "kysely";
+import { Operation as Operation$1, Pick as Pick$1 } from "@prisma/client/runtime/library";
+import { ExpectStatic } from "vitest";
+export * from "@powerhousedao/shared/document-drive";
+
+//#region src/cache/lru.d.ts
+/**
+ * An implementation of a Least Recently Used (LRU) cache storage that evicts items
+ * based on their total size in bytes. This cache storage is designed to work with
+ * the InMemoryCache class to provide size-limited caching of documents and drives.
+ *
+ * When the cache reaches its maximum size limit, it automatically removes the least
+ * recently accessed items to make space for new ones. The size of each cached item
+ * is calculated using the provided sizeCalculation function (defaults to object-sizeof).
+ *
+ * @template Value - The type of values stored in the cache.
+ */
+declare class LRUCacheStorage<Value extends {}> implements ICacheStorage$1 {
+  private cache;
+  private logger;
+  constructor(options: LRUCacheStorageOptions$1);
+  get(key: string): Value | undefined;
+  set(key: string, value: Value): this;
+  delete(key: string): boolean;
+  clear(): void;
+}
+//#endregion
+//#region src/cache/memory.d.ts
+declare class CacheStorageManager implements ICacheStorageManager$1 {
+  private index;
+  private cache;
+  constructor(cache: ICacheStorage$1);
+  createStorage<Value>(): ICacheStorage$1<Value>;
+}
+declare class InMemoryCache implements ICache$1 {
+  private cache;
+  private cacheStorageManager;
+  private idToDocument;
+  private idToDrive;
+  private slugToDriveId;
+  constructor(cache?: ICacheStorage$1);
+  clear(): void;
+  setDocument(documentId: string, document: PHDocument): Promise<void>;
+  getDocument<TDocument extends PHDocument>(documentId: string): Promise<TDocument | undefined>;
+  deleteDocument(documentId: string): Promise<boolean>;
+  setDrive(driveId: string, drive: DocumentDriveDocument): Promise<void>;
+  getDrive(driveId: string): Promise<DocumentDriveDocument | undefined>;
+  deleteDrive(driveId: string): Promise<boolean>;
+  setDriveBySlug(slug: string, drive: DocumentDriveDocument): Promise<void>;
+  getDriveBySlug(slug: string): Promise<DocumentDriveDocument | undefined>;
+  deleteDriveBySlug(slug: string): Promise<boolean>;
+}
+//#endregion
+//#region src/cache/redis.d.ts
+declare class RedisCache implements ICache$1 {
+  private logger;
+  private redis;
+  private timeoutInSeconds;
+  constructor(redis: RedisClientType, timeoutInSeconds?: number | undefined);
+  private static _getDocumentKey;
+  private static _getDriveKey;
+  private static _getDriveBySlugKey;
+  setDocument(documentId: string, document: PHDocument): Promise<void>;
+  getDocument<TDocument extends PHDocument>(documentId: string): Promise<TDocument | undefined>;
+  deleteDocument(documentId: string): Promise<boolean>;
+  setDrive(driveId: string, drive: DocumentDriveDocument): Promise<void>;
+  getDrive(driveId: string): Promise<DocumentDriveDocument | undefined>;
+  deleteDrive(driveId: string): Promise<boolean>;
+  setDriveBySlug(slug: string, drive: DocumentDriveDocument): Promise<void>;
+  getDriveBySlug(slug: string): Promise<DocumentDriveDocument | undefined>;
+  deleteDriveBySlug(slug: string): Promise<boolean>;
+}
+//#endregion
+//#region src/cache/types.d.ts
+interface IDocumentCache {}
+interface ICache {
+  setDocument(documentId: string, document: PHDocument): Promise<void>;
+  getDocument<TDocument extends PHDocument>(documentId: string): Promise<TDocument | undefined>;
+  deleteDocument(documentId: string): Promise<boolean>;
+  setDrive(driveId: string, drive: DocumentDriveDocument): Promise<void>;
+  setDriveBySlug(slug: string, drive: DocumentDriveDocument): Promise<void>;
+  getDrive(driveId: string): Promise<DocumentDriveDocument | undefined>;
+  getDriveBySlug(slug: string): Promise<DocumentDriveDocument | undefined>;
+  deleteDrive(driveId: string): Promise<boolean>;
+  deleteDriveBySlug(slug: string): Promise<boolean>;
+}
+/**
+ * Options for configuring an LRU (Least Recently Used) cache storage.
+ *
+ * @property maxSize - The maximum size of the cache in bytes. This defines the upper limit
+ * on the total size of objects that can be stored in the cache.
+ * @property sizeCalculation - An optional function to calculate the size of an object in bytes.
+ * If not provided, a default method will be used to determine the size.
+ */
+interface LRUCacheStorageOptions {
+  maxSize: number;
+  sizeCalculation?: (object: unknown) => number;
+}
+interface ICacheStorage<Value = unknown> {
+  get(key: string): Value | undefined;
+  set(key: string, value: Value): this;
+  delete(key: string): boolean;
+  clear(): void;
+}
+interface ICacheStorageManager {
+  createStorage<Value extends {}>(): ICacheStorage<Value>;
+}
+//#endregion
+//#region src/cache/util.d.ts
+declare const trimResultingState: <TDocument extends PHDocument>(document: TDocument) => TDocument;
+//#endregion
+//#region src/processors/processor-manager.d.ts
+declare class ProcessorManagerLegacy implements IProcessorManagerLegacy$1 {
+  private listeners;
+  private drive;
+  private readonly logger;
+  private processorsByDrive;
+  private idToFactory;
+  private identifierToListeners;
+  constructor(listeners: IListenerManager$1, drive: IDocumentDriveServer$1);
+  registerFactory(identifier: string, factory: ProcessorFactoryLegacy$1): Promise<void>;
+  unregisterFactory(identifier: string): Promise<void>;
+  registerDrive(driveId: string): Promise<void>;
+  /**
+   * Creates processors for a specific (drive, identifier) pair.
+   *
+   * This should be called once and only once for each (drive, identifier),
+   * unless unregisterFactory is called, which will remove them.
+   */
+  createProcessors(driveId: string, identifier: string, factory: ProcessorFactoryLegacy$1): Promise<void>;
+}
+//#endregion
+//#region src/processors/relational.d.ts
+declare const IS_RELATIONAL_DB_PROCESSOR: unique symbol;
+/**
+ * Base class for relational db processors that require a relational database storage.
+ * This class abstracts database initialization, migration management, and resource cleanup,
+ * allowing derived classes to focus on business logic.
+ */
+declare abstract class RelationalDbProcessorLegacy<TDatabaseSchema = unknown> implements IRelationalDbProcessorLegacy$1<TDatabaseSchema> {
+  protected _namespace: string;
+  protected _filter: RelationalDbProcessorFilterLegacy$1;
+  protected relationalDb: IRelationalDbLegacy$1<TDatabaseSchema>;
+  constructor(_namespace: string, _filter: RelationalDbProcessorFilterLegacy$1, relationalDb: IRelationalDbLegacy$1<TDatabaseSchema>);
+  static [IS_RELATIONAL_DB_PROCESSOR]: boolean;
+  static is(p: unknown): p is RelationalDbProcessorLegacy;
+  /**
+   * Returns the namespace for a given drive id.
+   * This method can be overridden by derived classes to provide a custom namespace.
+   */
+  static getNamespace(driveId: string): string;
+  static query<Schema>(this: RelationalDbProcessorClassLegacy$1<Schema>, driveId: string, db: IRelationalDbLegacy$1<any>): IRelationalQueryBuilderLegacy$1<Schema>;
+  /**
+   * Returns the filter for the processor.
+   * This method can be overridden by derived classes to provide a custom filter.
+   */
+  get filter(): RelationalDbProcessorFilterLegacy$1;
+  /**
+   * Returns the namespace used by the processor.
+   */
+  get namespace(): string;
+  get query(): IRelationalQueryBuilderLegacy$1<TDatabaseSchema>;
+  /**
+   * Abstract method that derived classes must implement.
+   * This method is meant to be called on subclasses to initialize and upgrade the database.
+   */
+  abstract initAndUpgrade(): Promise<void>;
+  /**
+   * Abstract method that derived classes must implement.
+   * This is where the business logic for processing document operations should be implemented.
+   */
+  abstract onStrands(strands: InternalTransmitterUpdate$1[]): Promise<void>;
+  /**
+   * Called when the processor is disconnected.
+   * This method is meant to be overridden by subclasses to clean up resources.
+   */
+  abstract onDisconnect(): Promise<void>;
+}
+declare function isRelationalDbProcessor(p: IProcessorLegacy$1): p is IRelationalDbProcessorLegacy$1;
+//#endregion
+//#region src/processors/utils.d.ts
+/**
+ * Hashes a string to a lowercase base-26 string.
+ * @param str The string to hash.
+ * @param length The length of the hash. Defaults to 10.
+ * @param algorithm The hashing algorithm to use. Defaults to "fnv1a".
+ * @returns The hashed string.
+ */
+declare function hashNamespaceLegacy(str: string, length?: number, algorithm?: HashAlgorithmsLegacy$1): string;
+/**
+ * Creates a RelationalDb instance with namespace support.
+ * @param baseDb The base RelationalDb instance to enhance.
+ * @param baseOptions The default options for namespace creation. Hashes namespace by default.
+ * @returns The enhanced RelationalDb instance.
+ */
+declare function createRelationalDbLegacy<Schema>(baseDb: IBaseRelationalDbLegacy$1<Schema>, baseOptions?: NamespaceOptions): IRelationalDbLegacy$1<Schema>;
+type NamespaceOptions = {
+  hashNamespace?: boolean;
+};
+declare function createNamespacedDbLegacy<Schema>(db: IBaseRelationalDbLegacy$1<any>, namespace: string, options?: NamespaceOptions): Promise<IRelationalDbLegacy$1<Schema>>;
+declare function createNamespacedQueryBuilderLegacy<Schema>(db: IBaseRelationalDbLegacy$1<any>, namespace: string, options?: NamespaceOptions): IRelationalQueryBuilderLegacy$1<Schema>;
+/**
+ * Returns a query builder for a RelationalDb instance.
+ * @param query The RelationalDb instance to convert.
+ * @returns The IRelationalQueryBuilder instance.
+ */
+declare function relationalDbToQueryBuilderLegacy<TSchema>(query: IBaseRelationalDbLegacy$1<TSchema>): IRelationalQueryBuilderLegacy$1<TSchema>;
+//#endregion
+//#region src/processors/types.d.ts
+type IRelationalQueryMethods = "selectFrom" | "selectNoFrom" | "with" | "withRecursive";
+type IRelationalQueryBuilderLegacy<Schema = unknown> = Pick<QueryCreator<Schema>, IRelationalQueryMethods> & {
+  withSchema: (schema: string) => IRelationalQueryBuilderLegacy<Schema>;
+};
+type IBaseRelationalDbLegacy<Schema = unknown> = Kysely<Schema>;
+/**
+ * The standardized relational database interface for relational db processors.
+ * This abstraction provides type-safe database operations while hiding the underlying
+ * database framework implementation details.
+ **/
+type IRelationalDbLegacy<Schema = unknown> = IBaseRelationalDbLegacy<Schema> & {
+  createNamespace<NamespaceSchema>(namespace: string): Promise<IRelationalDbLegacy<ExtractProcessorSchemaOrSelf<NamespaceSchema>>>;
+  queryNamespace<NamespaceSchema>(namespace: string): IRelationalQueryBuilderLegacy<NamespaceSchema>;
+};
+interface IProcessorHostModuleLegacy {
+  analyticsStore: IAnalyticsStore;
+  relationalDb: IRelationalDbLegacy;
+  processorApp: ProcessorApp;
+  config?: Map<string, unknown>;
+}
+/**
+ * Describes an object that can process strands.
+ */
+interface IProcessorLegacy {
+  /**
+   * Processes a list of strands.
+   *
+   * @param strands The strands to process.
+   */
+  onStrands(strands: InternalTransmitterUpdate$1[]): Promise<void>;
+  /**
+   * Called when the processor is disconnected. This is generally meant to
+   * clean up any resources that were allocated when the processor was created.
+   */
+  onDisconnect(): Promise<void>;
+}
+/**
+ * Relates a processor to a listener filter.
+ */
+type ProcessorRecordLegacy = {
+  processor: IProcessorLegacy;
+  filter: ListenerFilter;
+};
+/**
+ * A factory function that returns a list of processor records for a given drive.
+ *
+ * @param driveHeader The drive header to create processors for.
+ * @returns A list of processor records.
+ */
+type ProcessorFactoryLegacy = (driveHeader: PHDocumentHeader, processorApp?: ProcessorApp) => ProcessorRecordLegacy[] | Promise<ProcessorRecordLegacy[]>;
+/**
+ * Manages processor creation and destruction.
+ */
+interface IProcessorManagerLegacy {
+  /**
+   * Registers a processor factory for a given identifier. This will create
+   * processors for all drives that have already been registered.
+   *
+   * @param identifier Any identifier to associate with the factory.
+   * @param factory The factory to register.
+   */
+  registerFactory(identifier: string, factory: ProcessorFactoryLegacy): Promise<void>;
+  /**
+   * Unregisters a processor factory for a given identifier. This will remove
+   * all listeners that were created by the factory.
+   *
+   * @param identifier The identifier to unregister.
+   */
+  unregisterFactory(identifier: string): Promise<void>;
+  /**
+   * Registers a drive with the processor manager. This will create processors
+   * for the drive for all factories that have already been registered.
+   *
+   * @param driveId The drive to register.
+   */
+  registerDrive(driveId: string): Promise<void>;
+}
+type RelationalDbProcessorFilterLegacy = ListenerFilter;
+interface IRelationalDbProcessorLegacy<TDatabaseSchema = unknown> extends IProcessorLegacy {
+  namespace: string;
+  query: IRelationalQueryBuilderLegacy<TDatabaseSchema>;
+  filter: RelationalDbProcessorFilterLegacy;
+  initAndUpgrade(): Promise<void>;
+}
+type ExtractProcessorSchema<TProcessor> = TProcessor extends RelationalDbProcessorLegacy$1<infer TSchema> ? TSchema : never;
+type ExtractProcessorSchemaOrSelf<TProcessor> = TProcessor extends RelationalDbProcessorLegacy$1<infer TSchema> ? TSchema : TProcessor;
+type RelationalDbProcessorClassLegacy<TSchema> = typeof RelationalDbProcessorLegacy$1<TSchema>;
+type HashAlgorithmsLegacy = "fnv1a";
+//#endregion
+//#region src/queue/base.d.ts
+declare class MemoryQueue<T> implements IQueue$1<T> {
+  private id;
+  private running;
+  private deleted;
+  private items;
+  private dependencies;
+  constructor(id: string);
+  isRunning(): Promise<boolean>;
+  setRunning(running: boolean): Promise<void>;
+  setDeleted(deleted: boolean): Promise<void>;
+  isDeleted(): Promise<boolean>;
+  addJob(data: IJob$1<T>): Promise<void>;
+  getNextJob(): Promise<IJob$1<T> | undefined>;
+  amountOfJobs(): Promise<number>;
+  getId(): string;
+  isBlocked(): Promise<boolean>;
+  getJobs(): Promise<IJob$1<T>[]>;
+  addDependency(job: IJob$1<Job$1>): Promise<void>;
+  removeDependency(job: IJob$1<Job$1>): Promise<void>;
+}
+//#endregion
+//#region src/queue/event.d.ts
+interface EnqueuedJob {
+  jobId: string;
+  documentId: string;
+  scope: string;
+  timestampUtcMs: string;
+}
+declare class EventQueueManager implements IQueueManager$1 {
+  protected logger: document_model0.ILogger;
+  protected emitter: nanoevents.Emitter<QueueEvents$1>;
+  protected queues: Map<string, Map<string, IJobQueue$1>>;
+  protected globalQueue: EnqueuedJob[];
+  protected isFindingJob: boolean;
+  protected maxWorkers: number;
+  protected workers: number;
+  protected runningJobs: IJob$1<Job$1>[];
+  protected timeout: number;
+  protected delegate: IServerDelegate$1 | undefined;
+  protected onError: ((error: Error) => void) | undefined;
+  constructor(maxWorkers?: number, timeout?: number);
+  init(delegate: IServerDelegate$1, onError: (error: Error) => void): Promise<void>;
+  addJob(job: Job$1): Promise<JobId$1>;
+  getQueue(documentId: string, scope: string): IJobQueue$1;
+  getDocumentQueues(documentId: string): Map<string, IJobQueue$1> | undefined;
+  removeQueue(documentId: string, scope: string): boolean | undefined;
+  removeDocumentQueues(documentId: string): void;
+  protected removeJob(job: IJob$1<Job$1>): void;
+  protected handleJobCompleted(job: IJob$1<Job$1>, result: IOperationResult$1): Promise<void>;
+  protected isBusy(): boolean;
+  protected processNextJob(): Promise<void>;
+  protected findNextJob(): Promise<{
+    queue: IJobQueue$1;
+    job: IJob$1<Job$1>;
+  } | undefined>;
+  protected emit<K extends keyof QueueEvents$1>(event: K, ...args: Parameters<QueueEvents$1[K]>): void;
+  on<K extends keyof QueueEvents$1>(event: K, cb: QueueEvents$1[K]): Unsubscribe;
+}
+//#endregion
+//#region src/queue/utils.d.ts
+declare function isDocumentJob(job: Job$1): job is DocumentJob$1;
+declare function isOperationJob(job: Job$1): job is OperationJob$1;
+declare function isActionJob(job: Job$1): job is ActionJob$1;
+//#endregion
+//#region src/queue/types.d.ts
+interface BaseJob {
+  documentId: string;
+  actions?: Action[];
+  options?: AddOperationOptions$1;
+}
+interface DocumentJob extends Omit<BaseJob, "actions"> {
+  documentType: string;
+  header?: Partial<PHDocumentHeader>;
+  initialState?: Partial<PHBaseState>;
+}
+interface OperationJob extends BaseJob {
+  operations: Operation[];
+}
+interface ActionJob extends BaseJob {
+  actions: Action[];
+}
+type Job = DocumentJob | OperationJob | ActionJob;
+type JobId = string;
+interface QueueEvents {
+  jobAdded: (job: IJob<Job>) => void;
+  jobStarted: (job: IJob<Job>) => void;
+  jobCompleted: (job: IJob<Job>, result: IOperationResult$1) => void;
+  jobFailed: (job: IJob<Job>, error: Error) => void;
+  queueRemoved: (queue: {
+    documentId: string;
+    scope: string;
+  }) => void;
+}
+interface IServerDelegate {
+  exists: (documentId: string) => Promise<boolean>;
+  processJob: (job: Job) => Promise<IOperationResult$1>;
+}
+interface IQueueManager {
+  addJob: (job: Job) => Promise<JobId>;
+  init: (delegate: IServerDelegate, onError: (error: Error) => void) => Promise<void>;
+  on: <K extends keyof QueueEvents>(this: this, event: K, cb: QueueEvents[K]) => Unsubscribe;
+}
+type IJob<T> = {
+  jobId: JobId;
+} & T;
+interface IQueue<T> {
+  addJob(data: IJob<T>): Promise<void>;
+  getNextJob(): Promise<IJob<T> | undefined>;
+  amountOfJobs(): Promise<number>;
+  getId(): string;
+  isBlocked(): Promise<boolean>;
+  isDeleted(): Promise<boolean>;
+  isRunning(): Promise<boolean>;
+  setDeleted(deleted: boolean): Promise<void>;
+  setRunning(running: boolean): Promise<void>;
+  getJobs(): Promise<IJob<T>[]>;
+  addDependency: (job: IJob<Job>) => Promise<void>;
+  removeDependency: (job: IJob<Job>) => Promise<void>;
+}
+type IJobQueue = IQueue<Job>;
+//#endregion
+//#region src/read-mode/errors.d.ts
+declare abstract class ReadDriveError extends Error {}
+declare class ReadDriveNotFoundError extends ReadDriveError {
+  constructor(driveId: string);
+}
+declare class ReadDriveSlugNotFoundError extends ReadDriveError {
+  constructor(slug: string);
+}
+declare class ReadDocumentNotFoundError extends ReadDriveError {
+  constructor(drive: string, id: string);
+}
+//#endregion
+//#region src/read-mode/server.d.ts
+declare function ReadModeServer(Base: DocumentDriveServerConstructor$1): new (...args: ConstructorParameters<typeof Base>) => InstanceType<typeof Base> & IReadModeDriveServer$1;
+//#endregion
+//#region src/read-mode/types.d.ts
+type ReadModeDriveServerMixin = DocumentDriveServerMixin$1<IReadModeDriveServer>;
+type ReadDrivesListener = (drives: ReadDrive[], operation: "add" | "delete") => void;
+type ReadDrivesListenerUnsubscribe = () => void;
+interface IReadModeDriveServer extends IReadModeDriveService {
+  migrateReadDrive(id: string, options: RemoteDriveOptions$1): Promise<DocumentDriveDocument | ReadDriveNotFoundError$1>;
+  onReadDrivesUpdate(listener: ReadDrivesListener): Promise<ReadDrivesListenerUnsubscribe>;
+}
+type ReadDriveOptions = {
+  expectedDriveInfo?: DriveInfo$1;
+  filter?: ListenerFilter;
+};
+type ReadDriveContext = {
+  url: string;
+} & ReadDriveOptions;
+type ReadDrive = DocumentDriveDocument & {
+  readContext: ReadDriveContext;
+};
+interface IReadModeDriveService {
+  addReadDrive(url: string, options?: ReadDriveOptions): Promise<void>;
+  getReadDrives(): Promise<string[]>;
+  getReadDriveBySlug(slug: string): Promise<ReadDrive | ReadDriveSlugNotFoundError$1>;
+  getReadDrive(id: string): Promise<ReadDrive | ReadDriveNotFoundError$1>;
+  getReadDriveContext(id: string): Promise<ReadDriveContext | ReadDriveNotFoundError$1>;
+  fetchDrive(id: string): Promise<ReadDrive | ReadDriveNotFoundError$1>;
+  fetchDocument<TState extends PHBaseState = PHBaseState>(driveId: string, documentId: string, documentType: string): Promise<PHDocument<TState> | DocumentModelNotFoundError$1 | ReadDriveNotFoundError$1 | ReadDocumentNotFoundError$1>;
+  deleteReadDrive(id: string): Promise<ReadDriveNotFoundError$1 | undefined>;
+}
+type GetDocumentModelModule = (documentType: string) => DocumentModelModule<any>;
+//#endregion
+//#region src/utils/types.d.ts
+type DriveState = DriveInfo & Pick$1<DocumentDriveLocalState, "availableOffline" | "sharingType"> & {
+  nodes: Array<FolderNode | Omit<FileNode, "synchronizationUnits">>;
+};
+type DocumentGraphQLResult<TState extends PHBaseState = PHBaseState> = PHDocument<TState> & {
+  revision: number;
+  state: TState;
+  initialState: TState;
+  operations: (Operation$1 & {
+    inputText: string;
+  })[];
+};
+type GraphQLResult<T> = { [K in keyof T]: T[K] | null } & {
+  errors?: GraphQLError[];
+};
+type DriveInfo = {
+  id: string;
+  name: string;
+  slug: string;
+  icon?: string;
+  meta?: {
+    preferredEditor?: string;
+  };
+};
+interface IServerDelegateDrivesManager {
+  emit: (...args: Parameters<DriveEvents$1["defaultRemoteDrive"]>) => void;
+  detachDrive: (driveId: string) => Promise<void>;
+}
+interface IDefaultDrivesManager {
+  initializeDefaultRemoteDrives(): Promise<void>;
+  getDefaultRemoteDrives(): Map<string, DefaultRemoteDriveInfo$1>;
+  setDefaultDriveAccessLevel(url: string, level: RemoteDriveAccessLevel$1): Promise<void>;
+  setAllDefaultDrivesAccessLevel(level: RemoteDriveAccessLevel$1): Promise<void>;
+}
+type Task<T = void> = () => T;
+type AbortTask = () => void;
+type RunAsap<T> = (task: Task<T>) => AbortTask;
+//#endregion
+//#region src/server/error.d.ts
+declare class DocumentModelNotFoundError extends Error {
+  id: string;
+  constructor(id: string, cause?: unknown);
+}
+declare class OperationError extends Error {
+  status: ErrorStatus$1;
+  operation: Operation | undefined;
+  constructor(status: ErrorStatus$1, operation?: Operation, message?: string, cause?: unknown);
+}
+declare class ConflictOperationError extends OperationError {
+  constructor(existingOperation: Operation, newOperation: Operation);
+}
+declare class MissingOperationError extends OperationError {
+  constructor(index: number, operation: Operation);
+}
+declare enum DocumentAlreadyExistsReason {
+  ID = "id",
+  SLUG = "slug"
+}
+declare class DocumentAlreadyExistsError extends Error {
+  documentId: string;
+  constructor(documentId: string, reason?: DocumentAlreadyExistsReason);
+}
+declare class DocumentNotFoundError extends Error {
+  documentId: string;
+  constructor(documentId: string);
+}
+declare class SynchronizationUnitNotFoundError extends Error {
+  syncUnitId: SynchronizationUnitId$1;
+  constructor(syncUnitId: SynchronizationUnitId$1);
+}
+//#endregion
+//#region src/server/transmitter/types.d.ts
+type StrandUpdateSource = {
+  type: "local";
+} | {
+  type: "trigger";
+  trigger: Trigger;
+};
+interface ITransmitter {
+  transmit?(strands: StrandUpdate$1[], source: StrandUpdateSource): Promise<ListenerRevision$1[]>;
+  disconnect?(): Promise<void>;
+}
+interface InternalTransmitterService extends ITransmitter {
+  getName(): string;
+}
+type PullResponderTrigger = Omit<Trigger, "data" | "type"> & {
+  driveId: string;
+  filter: ListenerFilter;
+  data: PullResponderTriggerData;
+  type: "PullResponder";
+};
+type InternalOperationUpdate<TState extends PHBaseState = PHBaseState> = Omit<Operation, "scope"> & {
+  state: TState;
+  previousState: TState;
+};
+type InternalTransmitterUpdate = {
+  document: PHDocument;
+  driveId: string;
+  documentId: string;
+  documentType: string;
+  scope: string;
+  branch: string;
+  operations: InternalOperationUpdate[];
+  state: any;
+};
+type OperationUpdateGraphQL = Omit<OperationUpdate$1, "input"> & {
+  input: string;
+};
+type PullStrandsGraphQL = {
+  system: {
+    sync: {
+      strands: StrandUpdateGraphQL[];
+    };
+  };
+};
+type CancelPullLoop = () => void;
+type StrandUpdateGraphQL = Omit<StrandUpdate$1, "operations"> & {
+  operations: OperationUpdateGraphQL[];
+};
+interface IPullResponderTransmitter extends ITransmitter {
+  getStrands(options?: GetStrandsOptions$1): Promise<StrandUpdate$1[]>;
+}
+//#endregion
+//#region src/server/types.d.ts
+type Constructor<T = object> = new (...args: any[]) => T;
+type Mixin<T extends Constructor, I> = T & Constructor<InstanceType<T> & I>;
+type DriveInput = {
+  global: {
+    name: string;
+    icon?: string | null;
+  };
+  id?: string;
+  slug?: string;
+  preferredEditor?: string;
+  local?: Partial<DocumentDriveLocalState>;
+};
+type RemoteDriveAccessLevel = "READ" | "WRITE";
+type RemoteDriveOptions = DocumentDriveLocalState & {
+  pullFilter?: ListenerFilter;
+  pullInterval?: number;
+  expectedDriveInfo?: DriveInfo;
+  accessLevel?: RemoteDriveAccessLevel;
+};
+/**
+ * @deprecated In the future we will disallow this. Use the header field instead.
+ */
+type LegacyCreateDocumentInput = {
+  /**
+   * @deprecated In the future we will disallow this. Use the header field instead.
+   */
+  id: string;
+  documentType: string;
+};
+type CreateDocumentInputWithDocument<TDocument extends PHDocument> = {
+  document: TDocument;
+};
+type CreateDocumentInputWithHeader = {
+  header: PHDocumentHeader;
+};
+type CreateDocumentInputWithDocumentType = {
+  documentType: string;
+};
+type CreateDocumentInput<TDocument extends PHDocument> = LegacyCreateDocumentInput | CreateDocumentInputWithDocument<TDocument> | CreateDocumentInputWithHeader | CreateDocumentInputWithDocumentType;
+type IOperationResult<TDocument extends PHDocument = PHDocument> = {
+  status: UpdateStatus;
+  error?: OperationError;
+  operations: Operation[];
+  document: TDocument | undefined;
+  signals: SignalResult[];
+};
+type DriveOperationResult = IOperationResult<DocumentDriveDocument>;
+type SynchronizationUnitId = {
+  documentId: string;
+  scope: string;
+  branch: string;
+};
+type SynchronizationUnit = SynchronizationUnitId & {
+  documentType: string;
+  lastUpdated: string;
+  revision: number;
+};
+type SynchronizationUnitQuery = Omit<SynchronizationUnit, "revision" | "lastUpdated">;
+type ServerListener = {
+  driveId: string;
+  listenerId: string;
+  label?: string;
+  block: boolean;
+  system: boolean;
+  filter: ListenerFilter;
+  callInfo?: ListenerCallInfo;
+  transmitter?: ITransmitter;
+};
+type CreateListenerInput = {
+  driveId: string;
+  label?: string;
+  block: boolean;
+  system: boolean;
+  filter: ListenerFilter;
+  callInfo?: ListenerCallInfo;
+};
+declare enum ServerTransmitterType {
+  Internal = 0,
+  SwitchboardPush = 1,
+  PullResponder = 2,
+  SecureConnect = 3,
+  MatrixConnect = 4,
+  RESTWebhook = 5
+}
+type ListenerRevision = {
+  driveId: string;
+  documentId: string;
+  documentType: string;
+  scope: string;
+  branch: string;
+  status: UpdateStatus;
+  revision: number;
+  error?: string;
+};
+type ListenerRevisionWithError = Omit<ListenerRevision, "error"> & {
+  error?: Error;
+};
+type ListenerUpdate = {
+  listenerId: string;
+  listenerRevisions: ListenerRevision[];
+};
+type UpdateStatus = "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
+type ErrorStatus = Exclude<UpdateStatus, "SUCCESS">;
+type OperationUpdate = {
+  actionId: string;
+  timestampUtcMs: string;
+  index: number;
+  skip: number;
+  type: string;
+  input: object;
+  hash: string;
+  context?: ActionContext;
+  id?: string;
+};
+type StrandUpdate = {
+  driveId: string;
+  documentId: string;
+  documentType: string;
+  scope: string;
+  branch: string;
+  operations: OperationUpdate[];
+};
+type SyncStatus = "INITIAL_SYNC" | "SYNCING" | UpdateStatus;
+type PullSyncStatus = SyncStatus;
+type PushSyncStatus = SyncStatus;
+type SyncUnitStatusObject = {
+  push?: PushSyncStatus;
+  pull?: PullSyncStatus;
+};
+type AddRemoteDriveStatus = "SUCCESS" | "ERROR" | "PENDING" | "ADDING" | "ALREADY_ADDED";
+interface DriveEvents {
+  syncStatus: (driveId: string, status: SyncStatus, error?: Error, syncUnitStatus?: SyncUnitStatusObject, scope?: string, branch?: string) => void;
+  defaultRemoteDrive: (status: AddRemoteDriveStatus, defaultDrives: Map<string, DefaultRemoteDriveInfo>, driveInput: DefaultRemoteDriveInput, driveId?: string, driveName?: string, error?: Error) => void;
+  strandUpdate: (update: StrandUpdate) => void;
+  clientStrandsError: (driveId: string, trigger: Trigger, status: number, errorMessage: string) => void;
+  documentModelModules: (documentModelModules: DocumentModelModule[]) => void;
+  driveAdded: (drive: DocumentDriveDocument) => void;
+  driveDeleted: (driveId: string) => void;
+  documentAdded: (document: PHDocument) => void;
+  documentDeleted: (documentId: string) => void;
+  documentOperationsAdded: (documentId: string, operations: Operation[]) => void;
+  driveOperationsAdded: (driveId: string, operations: Operation[]) => void;
+  operationsAdded: (documentId: string, operations: Operation[]) => void;
+}
+type PartialRecord<K extends keyof any, T> = { [P in K]?: T };
+type RevisionsFilter = PartialRecord<string, number>;
+type GetDocumentOptions = ReducerOptions & {
+  revisions?: RevisionsFilter;
+  checkHashes?: boolean;
+};
+type AddOperationOptions = {
+  forceSync?: boolean;
+  source?: StrandUpdateSource;
+};
+type DefaultRemoteDriveInput = {
+  url: string;
+  options: RemoteDriveOptions;
+};
+type DefaultRemoteDriveInfo = DefaultRemoteDriveInput & {
+  status: AddRemoteDriveStatus;
+  metadata?: DriveInfo;
+};
+type RemoveDriveStrategy = "remove" | "detach";
+/**
+ * Options for removing old remote drives.
+ *
+ * Allows specifying different strategies for handling old remote drives:
+ *
+ * - `remove-all`: Remove all remote drives.
+ * - `preserve-all`: Preserve all remote drives (this is the default behavior).
+ * - `remove-by-id`: Remove the remote drives specified by their IDs.
+ * - `remove-by-url`: Remove the remote drives specified by their URLs.
+ * - `preserve-by-id`: Preserve remote drives by their IDs and remove the rest.
+ * - `preserve-by-url`: Preserve remote drives by their URLs and remove the rest.
+ * - `detach-by-id`: Detach remote drives by their IDs (changes the remote drive to a local drive).
+ * - `detach-by-url`: Detach remote drives by their URLs (changes the remote drive to a local drive).
+ * - `preserve-by-id-and-detach`: Preserve the remote drives specified by their IDs and detach the rest.
+ * - `preserve-by-url-and-detach`: Preserve the remote drives specified by their URLs and detach the rest.
+ *
+ * Each strategy is represented by an object with a `strategy` property and,
+ * depending on the strategy, additional properties such as `ids` or `urls`.
+ */
+type RemoveOldRemoteDrivesOption = {
+  strategy: "remove-all";
+} | {
+  strategy: "preserve-all";
+} | {
+  strategy: "remove-by-id";
+  ids: string[];
+} | {
+  strategy: "remove-by-url";
+  urls: string[];
+} | {
+  strategy: "preserve-by-id";
+  ids: string[];
+} | {
+  strategy: "preserve-by-url";
+  urls: string[];
+} | {
+  strategy: "detach-by-id";
+  ids: string[];
+} | {
+  strategy: "detach-by-url";
+  urls: string[];
+} | {
+  strategy: "preserve-by-id-and-detach";
+  ids: string[];
+} | {
+  strategy: "preserve-by-url-and-detach";
+  urls: string[];
+};
+type DocumentDriveServerOptions = {
+  defaultDrives?: {
+    loadOnInit?: boolean;
+    remoteDrives?: Array<DefaultRemoteDriveInput>;
+    removeOldRemoteDrives?: RemoveOldRemoteDrivesOption;
+  };
+  taskQueueMethod?: RunAsap<unknown> | null;
+  listenerManager?: ListenerManagerOptions;
+  jwtHandler?: (driveUrl: string, address: string | undefined, refresh?: boolean) => Promise<string>;
+  featureFlags?: {
+    enableDualActionCreate?: boolean;
+  };
+};
+type GetStrandsOptions = {
+  limit?: number;
+  since?: string;
+  fromRevision?: number;
+};
+type ListenerManagerOptions = {
+  sequentialUpdates?: boolean;
+};
+interface IBaseDocumentDriveServer {
+  initialize(): Promise<Error[] | null>;
+  get listeners(): IListenerManager;
+  setDocumentModelModules(models: DocumentModelModule<any>[]): void;
+  getDrives(): Promise<string[]>;
+  getDrivesSlugs(): Promise<string[]>;
+  addDrive(input: DriveInput, preferredEditor?: string): Promise<DocumentDriveDocument>;
+  addRemoteDrive(url: string, options: RemoteDriveOptions): Promise<DocumentDriveDocument>;
+  deleteDrive(driveId: string): Promise<void>;
+  getDrive(driveId: string, options?: GetDocumentOptions): Promise<DocumentDriveDocument>;
+  getDriveBySlug(slug: string): Promise<DocumentDriveDocument>;
+  getDriveIdBySlug(slug: string): Promise<DocumentDriveDocument["header"]["id"]>;
+  addDocument<TDocument extends PHDocument>(input: TDocument, meta?: PHDocumentMeta): Promise<TDocument>;
+  addDocument<TDocument extends PHDocument>(documentType: string, meta?: PHDocumentMeta): Promise<TDocument>;
+  deleteDocument(documentId: string): Promise<void>;
+  getDocuments(parentId: string): Promise<string[]>;
+  getDocument<TDocument extends PHDocument>(documentId: string, options?: GetDocumentOptions): Promise<TDocument>;
+  /**
+   * @deprecated Use getDocument(documentId, options) instead. This method will be removed in the future.
+   */
+  getDocument<TDocument extends PHDocument>(driveId: string, documentId: string, options?: GetDocumentOptions): Promise<TDocument>;
+  queueDocument<TDocument extends PHDocument>(input: CreateDocumentInput<TDocument>, options?: AddOperationOptions): Promise<IOperationResult>;
+  addOperation(documentId: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use addOperation(documentId, operation, options) instead. This method will be removed in the future.
+   */
+  addOperation(driveId: string, documentId: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+  addOperations(documentId: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use addOperations(documentId, operations, options) instead. This method will be removed in the future.
+   */
+  addOperations(driveId: string, documentId: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+  queueOperation(documentId: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use queueOperation(documentId, operation, options) instead. This method will be removed in the future.
+   */
+  queueOperation(driveId: string, documentId: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+  queueOperations(documentId: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use queueOperations(documentId, operations, options) instead. This method will be removed in the future.
+   */
+  queueOperations(driveId: string, documentId: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+  queueAction(documentId: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use queueAction(documentId, action, options) instead. This method will be removed in the future.
+   */
+  queueAction(driveId: string, documentId: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+  queueActions(documentId: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use queueActions(documentId, actions, options) instead. This method will be removed in the future.
+   */
+  queueActions(driveId: string, documentId: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use the {@link addOperation} method instead.
+   */
+  addDriveOperation(driveId: string, operation: Operation, options?: AddOperationOptions): Promise<DriveOperationResult>;
+  /**
+   * @deprecated Use the {@link addOperations} method instead.
+   */
+  addDriveOperations(driveId: string, operations: Operation[], options?: AddOperationOptions): Promise<DriveOperationResult>;
+  /**
+   * @deprecated Use the {@link queueOperation} method instead.
+   */
+  queueDriveOperation(driveId: string, operation: Operation, options?: AddOperationOptions): Promise<DriveOperationResult>;
+  /**
+   * @deprecated Use the {@link queueOperations} method instead.
+   */
+  queueDriveOperations(driveId: string, operations: Operation[], options?: AddOperationOptions): Promise<DriveOperationResult>;
+  /**
+   * @deprecated Use the {@link queueAction} method instead.
+   */
+  queueDriveAction(driveId: string, action: DocumentDriveAction, options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use the {@link queueActions} method instead.
+   */
+  queueDriveActions(driveId: string, actions: DocumentDriveAction[], options?: AddOperationOptions): Promise<IOperationResult>;
+  addAction(documentId: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use addAction(documentId, action, options) method instead. This method will be removed in the future.
+   */
+  addAction(driveId: string, documentId: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+  addActions(documentId: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use addActions(documentId, actions, options) instead. This method will be removed in the future.
+   */
+  addActions(driveId: string, documentId: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use the {@link addAction} method with a {@link AddFileAction} and call {@link addDocument} if the document needs to be created.
+   */
+  addDriveAction(driveId: string, action: LegacyAddFileAction, options?: AddOperationOptions): Promise<DriveOperationResult>;
+  /**
+   * @deprecated Use the {@link addAction} method instead.
+   */
+  addDriveAction(driveId: string, action: DocumentDriveAction, options?: AddOperationOptions): Promise<DriveOperationResult>;
+  /**
+   * @deprecated Use the {@link addActions} method instead.
+   */
+  addDriveActions(driveId: string, actions: DocumentDriveAction[], options?: AddOperationOptions): Promise<DriveOperationResult>;
+  getSyncStatus(documentId: string, scope?: string, branch?: string): SyncStatus | SynchronizationUnitNotFoundError;
+  /** Internal methods **/
+  getDocumentModelModules(): DocumentModelModule[];
+  on<K extends keyof DriveEvents>(event: K, cb: DriveEvents[K]): Unsubscribe;
+  setGenerateJwtHandler(handler: (driveUrl: string) => Promise<string>): void;
+  removeJwtHandler(): void;
+  generateJwtHandler?: (driveUrl: string) => Promise<string>;
+}
+type IDocumentDriveServer = IBaseDocumentDriveServer & IDefaultDrivesManager & IReadModeDriveServer;
+type DriveUpdateErrorHandler = (error: Error, driveId: string, listener: ListenerState) => void;
+interface IListenerManager {
+  initialize(handler: DriveUpdateErrorHandler): Promise<void>;
+  removeDrive(driveId: DocumentDriveDocument["header"]["id"]): Promise<void>;
+  driveHasListeners(driveId: string): boolean;
+  setListener(driveId: string, listener: ServerListener): Promise<void>;
+  removeListener(driveId: string, listenerId: string): Promise<boolean>;
+  getListenerState(driveId: string, listenerId: string): ListenerState;
+  getStrands(driveId: string, listenerId: string, options?: GetStrandsOptions): Promise<StrandUpdate[]>;
+  updateSynchronizationRevisions(syncUnits: SynchronizationUnit[], source: StrandUpdateSource, willUpdate?: (listeners: ServerListener[]) => void, onError?: (error: Error, driveId: string, listener: ListenerState) => void, forceSync?: boolean): Promise<ListenerUpdate[]>;
+  updateListenerRevision(listenerId: string, driveId: string, syncUnitId: SynchronizationUnitId, listenerRev: number): Promise<void>;
+  removeSyncUnits(parentId: string, syncUnits: SynchronizationUnitId[]): Promise<void>;
+  setGenerateJwtHandler(handler: (driveUrl: string) => Promise<string>): void;
+  removeJwtHandler(): void;
+  generateJwtHandler?: (driveUrl: string) => Promise<string>;
+}
+type ListenerStatus = "CREATED" | "PENDING" | "SUCCESS" | "MISSING" | "CONFLICT" | "ERROR";
+type SynchronizationUnitMap = ISyncUnitMap<SyncronizationUnitState>;
+interface ListenerState {
+  driveId: string;
+  block: boolean;
+  pendingTimeout: string;
+  listener: ServerListener;
+  syncUnits: SynchronizationUnitMap;
+  listenerStatus: ListenerStatus;
+}
+interface SyncronizationUnitState {
+  listenerRev: number;
+  lastUpdated: string;
+}
+interface ITransmitterFactory {
+  instance(transmitterType: string, listener: ServerListener, driveServer: IBaseDocumentDriveServer): ITransmitter;
+}
+interface IEventEmitter {
+  emit<K extends keyof DriveEvents>(event: K, ...args: Parameters<DriveEvents[K]>): void;
+  on<K extends keyof DriveEvents>(event: K, cb: DriveEvents[K]): Unsubscribe;
+}
+interface ISynchronizationManager {
+  setDocumentModelModules(arg0: DocumentModelModule[]): void;
+  getSynchronizationUnits(parentId?: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[]): Promise<SynchronizationUnit[]>;
+  getSynchronizationUnitsIds(parentId?: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[]): Promise<SynchronizationUnitQuery[]>;
+  getSynchronizationUnit(syncId: SynchronizationUnitId): Promise<SynchronizationUnit | undefined>;
+  getOperationData(syncId: SynchronizationUnitId, filter: GetStrandsOptions): Promise<OperationUpdate[]>;
+  getSyncStatus(documentId: string, scope?: string, branch?: string): SyncStatus | SynchronizationUnitNotFoundError;
+  getSyncStatus(syncId: SynchronizationUnitId): SyncStatus | SynchronizationUnitNotFoundError;
+  updateSyncStatus(documentId: string, status: Partial<SyncUnitStatusObject> | null, error?: Error, scope?: string, branch?: string): void;
+  updateSyncStatus(syncId: SynchronizationUnitId, status: Partial<SyncUnitStatusObject> | null, error?: Error): void;
+  initializeDriveSyncStatus(driveId: string, drive: DocumentDriveDocument): Promise<void>;
+  getCombinedSyncUnitStatus(syncUnitStatus: SyncUnitStatusObject): SyncStatus;
+}
+type SharingType = "LOCAL" | "CLOUD" | "PUBLIC";
+type DocumentDriveServerConstructor = Constructor<BaseDocumentDriveServer>;
+type DocumentDriveServerMixin<I> = Mixin<typeof BaseDocumentDriveServer, I>;
+/**
+ * Interface for a specialized Map implementation that manages synchronization units.
+ * Each unit is identified by a SynchronizationUnitId which consists of documentId, scope, and branch.
+ */
+interface ISyncUnitMap<Value> {
+  set(id: SynchronizationUnitId, state: Value): this;
+  get(id: SynchronizationUnitId): Value | undefined;
+  has(id: SynchronizationUnitId): boolean;
+  delete(id: SynchronizationUnitId): boolean;
+  clear(): void;
+  get size(): number;
+  keys(): IterableIterator<SynchronizationUnitId>;
+  values(): IterableIterator<Value>;
+  entries(): IterableIterator<[SynchronizationUnitId, Value]>;
+  [Symbol.iterator](): IterableIterator<[SynchronizationUnitId, Value]>;
+  forEach(callbackfn: (value: Value, key: SynchronizationUnitId, map: ISyncUnitMap<Value>) => void, thisArg?: any): void;
+  deleteByDocumentId(documentId: string): void;
+  deleteByDocumentIdAndScope(documentId: string, scope: string): void;
+  getAllByDocumentId(documentId: string): [SynchronizationUnitId, Value][];
+  getAllByDocumentIdAndScope(documentId: string, scope: string): [SynchronizationUnitId, Value][];
+}
+//#endregion
+//#region src/storage/browser.d.ts
+declare class BrowserStorage implements IDriveOperationStorage$1, IDocumentStorage$1, IDocumentAdminStorage$1 {
+  private logger;
+  private db;
+  static DBName: string;
+  static SEP: string;
+  static DOCUMENT_KEY: string;
+  static MANIFEST_KEY: string;
+  static SLUG_MANIFEST_KEY: string;
+  constructor(namespace?: string);
+  findStorageUnitsBy(filter: IStorageUnitFilter$1, limit: number, cursor?: string): Promise<{
+    units: IStorageUnit$1[];
+    nextCursor?: string;
+  }>;
+  resolveIds(slugs: string[], signal?: AbortSignal): Promise<string[]>;
+  resolveSlugs(ids: string[], signal?: AbortSignal): Promise<string[]>;
+  clear(): Promise<void>;
+  exists(documentId: string): Promise<boolean>;
+  create(document: PHDocument): Promise<void>;
+  get<TDocument extends PHDocument>(documentId: string): Promise<TDocument>;
+  getBySlug<TDocument extends PHDocument>(slug: string): Promise<TDocument>;
+  findByType(documentModelType: string, limit?: number, cursor?: string): Promise<{
+    documents: string[];
+    nextCursor: string | undefined;
+  }>;
+  delete(documentId: string): Promise<boolean>;
+  removeChild(parentId: string, childId: string): Promise<boolean>;
+  addChild(parentId: string, childId: string): Promise<void>;
+  getChildren(parentId: string): Promise<string[]>;
+  getParents(childId: string): Promise<string[]>;
+  private getManifest;
+  private updateDriveManifest;
+  private getSlugManifest;
+  private updateSlugManifest;
+  addDocumentOperations(id: string, operations: Operation[], document: PHDocument): Promise<void>;
+  addDriveOperations(id: string, operations: Operation[], document: PHDocument): Promise<void>;
+  getSynchronizationUnitsRevision(units: SynchronizationUnitQuery$1[]): Promise<{
+    documentId: string;
+    documentType: string;
+    scope: string;
+    branch: string;
+    lastUpdated: string;
+    revision: number;
+  }[]>;
+  migrateOperationSignatures(): Promise<void>;
+  private migrateDrive;
+  private migrateDocument;
+  buildDocumentKey(documentId: string): string;
+  buildManifestKey(driveId: string): string;
+}
+//#endregion
+//#region src/storage/memory.d.ts
+declare class MemoryStorage implements IDriveOperationStorage$1, IDocumentStorage$1, IDocumentAdminStorage$1 {
+  private logger;
+  private documents;
+  private driveManifests;
+  private slugToDocumentId;
+  constructor();
+  resolveIds(slugs: string[], signal?: AbortSignal): Promise<string[]>;
+  resolveSlugs(ids: string[], signal?: AbortSignal): Promise<string[]>;
+  exists(documentId: string): Promise<boolean>;
+  create(document: PHDocument): Promise<void>;
+  get<TDocument extends PHDocument>(documentId: string): Promise<TDocument>;
+  getBySlug<TDocument extends PHDocument>(slug: string): Promise<TDocument>;
+  findByType(documentModelType: string, limit?: number, cursor?: string): Promise<{
+    documents: string[];
+    nextCursor: string | undefined;
+  }>;
+  delete(documentId: string): Promise<boolean>;
+  addChild(parentId: string, childId: string): Promise<void>;
+  removeChild(parentId: string, childId: string): Promise<boolean>;
+  getChildren(parentId: string): Promise<string[]>;
+  getParents(childId: string): Promise<string[]>;
+  clear(): Promise<void>;
+  addDocumentOperations(id: string, operations: Operation[], document: PHDocument): Promise<void>;
+  addDriveOperations(id: string, operations: Operation[], document: PHDocument): Promise<void>;
+  getSynchronizationUnitsRevision(units: SynchronizationUnitQuery$1[]): Promise<{
+    documentId: string;
+    documentType: string;
+    scope: string;
+    branch: string;
+    lastUpdated: string;
+    revision: number;
+  }[]>;
+  findStorageUnitsBy(filter: IStorageUnitFilter$1, limit: number, cursor?: string): Promise<{
+    units: IStorageUnit$1[];
+    nextCursor?: string;
+  }>;
+  private getManifest;
+  private updateDriveManifest;
+}
+//#endregion
+//#region src/storage/path-encoding.d.ts
+/**
+ * Checks if a string is a UUID v4.
+ */
+declare function isUUID(id: string): boolean;
+/**
+ * Checks if a string contains Base64 special characters that need encoding.
+ */
+declare function hasBase64SpecialChars(id: string): boolean;
+/**
+ * Encodes a document ID to a filesystem-safe string.
+ * - UUIDs pass through unchanged
+ * - Base64 signatures are encoded to Base64url
+ */
+declare function encodeDocumentIdForPath(documentId: string): string;
+/**
+ * Decodes a filesystem-safe string back to original document ID.
+ * - UUIDs pass through unchanged
+ * - Base64url is decoded back to Base64 (for signatures)
+ */
+declare function decodeDocumentIdFromPath(encodedId: string): string;
+//#endregion
+//#region src/storage/types.d.ts
+type IStorageUnit = {
+  /** The id of the document. If '*' then select all. */documentId: string; /** The type of the document model. If '*' then select all. */
+  documentModelType: string; /** The scope of the document. If '*' then select all. */
+  scope: string; /** The branch of the document. If '*' then select all. */
+  branch: string;
+};
+type IStorageUnitFilter = {
+  /** The ids of the parent documents. If '*' then select all. */parentId?: string[]; /** The ids of the documents. If '*' then select all. */
+  documentId?: string[]; /** The types of the document models. If '*' then select all. */
+  documentModelType?: string[]; /** The scopes of the documents. If '*' then select all. */
+  scope?: string[]; /** The branches of the documents. If '*' then select all. */
+  branch?: string[];
+};
+type ResolvedStorageUnitFilter = Required<{ [K in keyof IStorageUnitFilter]: Set<string> | null }>;
+interface IStorageUnitStorage {
+  /**
+   * Finds storage units based on the provided filter.
+   *
+   * @param filter - The filter to apply.
+   * @param limit - The maximum number of documents to return.
+   * @param cursor - The cursor to start the search from.
+   */
+  findStorageUnitsBy: (filter: IStorageUnitFilter, limit: number, cursor?: string) => Promise<{
+    units: IStorageUnit[];
+    nextCursor?: string;
+  }>;
+}
+/**
+ * Describes the storage interface for documents.
+ */
+interface IDocumentStorage extends IStorageUnitStorage {
+  /**
+   * Resolves a list of ids from a list of slugs.
+   *
+   * > TODO: This function is part of the future IDocumentView interface.
+   *
+   * @param slugs - Required, the list of document slugs
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The parallel list of slugs
+   */
+  resolveIds(slugs: string[], signal?: AbortSignal): Promise<string[]>;
+  /**
+   * Resolves a list of slugs from a list of ids.
+   *
+   * @param ids - Required, the list of document ids
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The parallel list of ids
+   */
+  resolveSlugs(ids: string[], signal?: AbortSignal): Promise<string[]>;
+  /**
+   * Returns true if and only if the document exists.
+   *
+   * @param documentId - The id of the document to check.
+   */
+  exists(documentId: string): Promise<boolean>;
+  /**
+   * Creates a new document with the given id.
+   *
+   * @param documentId - The id of the document to create.
+   * @param document - The document to create.
+   *
+   * @throws Error if the document with a matching id OR slug already exists.
+   */
+  create(document: PHDocument): Promise<void>;
+  /**
+   * Returns the document with the given id.
+   *
+   * @param documentId - The id of the document to get.
+   *
+   * @throws Error if the document does not exist.
+   */
+  get<TDocument extends PHDocument>(documentId: string): Promise<TDocument>;
+  /**
+   * Returns the document with the given slug.
+   *
+   * @param slug - The slug of the document to get.
+   *
+   * @throws Error if the document does not exist.
+   */
+  getBySlug<TDocument extends PHDocument>(slug: string): Promise<TDocument>;
+  /**
+   * Returns ids of all documents of the given document-model type.
+   *
+   * @param documentModelType - The type of the documents to get.
+   * @param limit - The maximum number of documents to return.
+   * @param cursor - The cursor to start the search from.
+   *
+   */
+  findByType(documentModelType: string, limit?: number, cursor?: string): Promise<{
+    documents: string[];
+    nextCursor: string | undefined;
+  }>;
+  /**
+   * Deletes the document with the given id. Also deletes any child documents
+   * that are only children of this document.
+   *
+   * @param documentId - The id of the document to delete.
+   *
+   * @returns true if the document was deleted, false if it did not exist.
+   */
+  delete(documentId: string): Promise<boolean>;
+  /**
+   * Associates a child document with a parent document.
+   *
+   * A child document can belong to many parent documents. However, a child
+   * cannot be added to itself, or added as a child of a child of itself.
+   *
+   * @param parentId - The id of the parent document.
+   * @param childId - The id of the child document to add.
+   */
+  addChild(parentId: string, childId: string): Promise<void>;
+  /**
+   * Removes a child document from a parent document.
+   *
+   * @param parentId - The id of the parent document.
+   * @param childId - The id of the child document to remove.
+   *
+   * @returns true if the child document was removed from the parent document,
+   * false if the child document was not a child of the parent document.
+   */
+  removeChild(parentId: string, childId: string): Promise<boolean>;
+  /**
+   * Returns all child documents of the parent document with the given id.
+   *
+   * @param parentId - The id of the parent document.
+   */
+  getChildren(parentId: string): Promise<string[]>;
+  /**
+   * Returns all parent documents of the child document with the given id.
+   *
+   * @param childId - The id of the child document.
+   */
+  getParents(childId: string): Promise<string[]>;
+}
+/**
+ * Storage interface that allows for deletion.
+ */
+interface IDocumentAdminStorage extends IDocumentStorage {
+  /**
+   * Clears the storage.
+   */
+  clear(): Promise<void>;
+}
+/**
+ * Describes the storage interface for document operations.
+ */
+interface IDocumentOperationStorage {
+  addDocumentOperations<TDocument extends PHDocument>(id: string, operations: Operation[], document: PHDocument): Promise<void>;
+  addDocumentOperationsWithTransaction?<TDocument extends PHDocument>(id: string, callback: (document: TDocument) => Promise<{
+    operations: Operation[];
+    document: PHDocument;
+  }>): Promise<void>;
+  getOperationResultingState?(id: string, index: number, scope: string, branch: string): Promise<string | undefined>;
+  getSynchronizationUnitsRevision(units: SynchronizationUnitQuery$1[]): Promise<{
+    documentId: string;
+    documentType: string;
+    scope: string;
+    branch: string;
+    lastUpdated: string;
+    revision: number;
+  }[]>;
+}
+/**
+ * Describes the storage interface for drive operations.
+ */
+interface IDriveOperationStorage extends IDocumentOperationStorage {
+  addDriveOperations(id: string, operations: Operation[], document: PHDocument): Promise<void>;
+  addDriveOperationsWithTransaction?(drive: string, callback: (document: DocumentDriveDocument) => Promise<{
+    operations: Operation[];
+    document: PHDocument;
+  }>): Promise<void>;
+  getDriveOperationResultingState?(drive: string, index: number, scope: string, branch: string): Promise<string | undefined>;
+}
+//#endregion
+//#region src/storage/utils.d.ts
+declare const resolveStorageUnitsFilterComponent: (component: string[] | undefined) => Set<string> | null;
+declare const resolveStorageUnitsFilter: (filter: IStorageUnitFilter$1) => ResolvedStorageUnitFilter$1;
+declare const setUnion: <T>(base: Set<T>, ...iterables: Iterable<T>[]) => Set<T>;
+declare const setIntersection: <T>(left: Set<T>, right: Set<T>) => Set<T>;
+//#endregion
+//#region src/server/base-server.d.ts
+declare class BaseDocumentDriveServer implements IBaseDocumentDriveServer, IDefaultDrivesManager {
+  protected logger: document_model0.ILogger;
+  private documentModelModules;
+  private legacyStorage;
+  private documentStorage;
+  private cache;
+  private queueManager;
+  eventEmitter: IEventEmitter;
+  protected options: Required<DocumentDriveServerOptions>;
+  private listenerManager;
+  private synchronizationManager;
+  generateJwtHandler?: (driveUrl: string) => Promise<string>;
+  private defaultDrivesManager;
+  private defaultDrivesManagerDelegate;
+  private queueDelegate;
+  private triggerMap;
+  private initializePromise;
+  protected enableDualActionCreate: boolean;
+  constructor(documentModelModules: DocumentModelModule[], storage: IDriveOperationStorage, documentStorage: IDocumentStorage, cache: ICache, queueManager: IQueueManager, eventEmitter: IEventEmitter, synchronizationManager: ISynchronizationManager, listenerManager: IListenerManager, options?: DocumentDriveServerOptions);
+  get listeners(): IListenerManager;
+  initialize(): Promise<Error[] | null>;
+  private _initialize;
+  setDocumentModelModules(modules: DocumentModelModule<any>[]): void;
+  initializeDefaultRemoteDrives(): Promise<void>;
+  getDefaultRemoteDrives(): Map<string, DefaultRemoteDriveInfo>;
+  setDefaultDriveAccessLevel(url: string, level: RemoteDriveAccessLevel): Promise<void>;
+  setAllDefaultDrivesAccessLevel(level: RemoteDriveAccessLevel): Promise<void>;
+  private getOperationSource;
+  private handleListenerError;
+  private shouldSyncRemoteDrive;
+  private startSyncRemoteDrive;
+  private stopSyncRemoteDrive;
+  private _initializeDrive;
+  protected getDocumentModelModule(documentType: string): DocumentModelModule;
+  getDocumentModelModules(): DocumentModelModule[];
+  addDocument<TDocument extends PHDocument>(document: TDocument, meta?: PHDocumentMeta): Promise<TDocument>;
+  addDocument<TDocument extends PHDocument>(type: string, meta?: PHDocumentMeta): Promise<TDocument>;
+  addDrive(input: DriveInput, preferredEditor?: string): Promise<DocumentDriveDocument>;
+  addRemoteDrive(url: string, options: RemoteDriveOptions): Promise<DocumentDriveDocument>;
+  deleteDrive(driveId: string): Promise<void>;
+  getDrives(): Promise<string[]>;
+  getDrivesSlugs(): Promise<string[]>;
+  getDrive(driveId: string, options?: GetDocumentOptions$1): Promise<any>;
+  getDriveBySlug(slug: string, options?: GetDocumentOptions$1): Promise<any>;
+  getDriveIdBySlug(slug: string): Promise<string>;
+  getDocument<TDocument extends PHDocument>(documentId: string, options?: GetDocumentOptions$1): Promise<TDocument>;
+  /**
+   * @deprecated Use getDocument(documentId, options) instead. This method will be removed in the future.
+   */
+  getDocument<TDocument extends PHDocument>(driveId: string, documentId: string, options?: GetDocumentOptions$1): Promise<TDocument>;
+  private _getDocument;
+  getDocuments(driveId: string): Promise<string[]>;
+  protected addChild(parentId: string, documentId: string): Promise<void>;
+  protected removeChild(parentId: string, documentId: string): Promise<void>;
+  protected createDocument<TDocument extends PHDocument>(input: CreateDocumentInput<TDocument>, source: StrandUpdateSource, meta?: PHDocumentMeta): Promise<TDocument>;
+  private createDocumentLegacy;
+  private createDocumentDualAction;
+  deleteDocument(documentId: string): Promise<void>;
+  _processOperations(documentId: string, documentStorage: PHDocument, operations: Operation[]): Promise<{
+    readonly document: PHDocument;
+    readonly operationsApplied: Operation[];
+    readonly signals: SignalResult[];
+    readonly error: OperationError | undefined;
+  }>;
+  private _addDocumentResultingStage;
+  private _buildDocument;
+  private _performOperation;
+  addOperation(documentId: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use addOperation(documentId, operation, options) instead. This method will be removed in the future.
+   */
+  addOperation(driveId: string, documentId: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+  private _addOperations;
+  queueDocument<TDocument extends PHDocument>(input: CreateDocumentInput<TDocument>, options?: AddOperationOptions): Promise<IOperationResult>;
+  queueOperation(documentId: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use queueOperation(documentId, operation, options) instead. This method will be removed in the future.
+   */
+  queueOperation(driveId: string, documentId: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+  private resultIfExistingOperations;
+  queueOperations(documentId: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use queueOperations(documentId, operations, options) instead. This method will be removed in the future.
+   */
+  queueOperations(driveId: string, documentId: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+  private _queueOperations;
+  queueAction(documentId: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use queueAction(documentId, action, options) instead. This method will be removed in the future.
+   */
+  queueAction(driveId: string, documentId: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+  queueActions(documentId: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use queueActions(documentId, actions, options) instead. This method will be removed in the future.
+   */
+  queueActions(driveId: string, documentId: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+  private _queueActions;
+  /**
+   * @deprecated Use the {@link queueAction} method instead.
+   */
+  queueDriveAction(driveId: string, action: DocumentDriveAction | Action, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+  /**
+   * @deprecated Use the {@link queueActions} method instead.
+   */
+  queueDriveActions(driveId: string, actions: (DocumentDriveAction | Action)[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+  addOperations(documentId: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use addOperations(documentId, operations, options) instead. This method will be removed in the future.
+   */
+  addOperations(driveId: string, documentId: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+  private processOperations;
+  /**
+   * @deprecated Use the {@link addOperation} method instead.
+   */
+  addDriveOperation(driveId: string, operation: Operation, options?: AddOperationOptions): Promise<DriveOperationResult>;
+  private _addDriveOperations;
+  /**
+   * @deprecated Use the {@link queueOperation} method instead.
+   */
+  queueDriveOperation(driveId: string, operation: Operation, options?: AddOperationOptions): Promise<DriveOperationResult>;
+  private resultIfExistingDriveOperations;
+  /**
+   * @deprecated Use the {@link queueOperations} method instead.
+   */
+  queueDriveOperations(driveId: string, operations: Operation[], options?: AddOperationOptions): Promise<DriveOperationResult>;
+  /**
+   * @deprecated Use the {@link addOperations} method instead.
+   */
+  addDriveOperations(driveId: string, operations: Operation[], options?: AddOperationOptions): Promise<DriveOperationResult>;
+  private processDriveOperations;
+  private _buildOperations;
+  addAction(documentId: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use addAction(documentId, action, options) instead. This method will be removed in the future.
+   */
+  addAction(driveId: string, documentId: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+  private _addAction;
+  addActions(documentId: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+  /**
+   * @deprecated Use addActions(documentId, actions, options) instead. This method will be removed in the future.
+   */
+  addActions(driveId: string, documentId: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+  private processActions;
+  /**
+   * @deprecated Use the {@link addAction} method instead with a {@link AddFileAction} and call {@link addDocument} if the document needs to be created.
+   */
+  /**
+   * @deprecated Use the {@link addAction} method instead with a {@link AddFileAction} and call {@link addDocument} if the document needs to be created.
+   */
+  addDriveAction(driveId: string, action: LegacyAddFileAction, options?: AddOperationOptions): Promise<DriveOperationResult>;
+  /**
+   * @deprecated Use the {@link addAction} method instead.
+   */
+  addDriveAction(driveId: string, action: DocumentDriveAction | Action, options?: AddOperationOptions): Promise<DriveOperationResult>;
+  private _legacyAddFileAction;
+  /**
+   * @deprecated Use the {@link addActions} method instead.
+   */
+  addDriveActions(driveId: string, actions: (DocumentDriveAction | Action)[], options?: AddOperationOptions): Promise<DriveOperationResult>;
+  private processDriveActions;
+  detachDrive(driveId: string): Promise<void>;
+  getSyncStatus(documentId: string, scope?: string, branch?: string): SyncStatus | SynchronizationUnitNotFoundError;
+  on<K extends keyof DriveEvents>(event: K, cb: DriveEvents[K]): Unsubscribe;
+  private emit;
+  updateSyncStatus(syncUnitId: string, status: Partial<SyncUnitStatusObject> | null, error?: Error): void;
+  initializeDriveSyncStatus(driveId: string, drive: DocumentDriveDocument): Promise<void>;
+  getCombinedSyncUnitStatus(syncUnitStatus: SyncUnitStatusObject): SyncStatus;
+  private saveStrand;
+  setGenerateJwtHandler(handler: (driveUrl: string) => Promise<string>): void;
+  removeJwtHandler(): void;
+}
+declare const DocumentDriveServer: new (...args: ConstructorParameters<DocumentDriveServerConstructor>) => InstanceType<DocumentDriveServerConstructor> & IReadModeDriveServer;
+//#endregion
+//#region src/server/builder.d.ts
+/**
+ * Builder class for constructing Reactor instances with proper configuration
+ */
+declare class ReactorBuilder {
+  documentModelModules: DocumentModelModule<any>[];
+  storage?: IDriveOperationStorage$1;
+  cache?: ICache$1;
+  queueManager?: IQueueManager$1;
+  eventEmitter?: IEventEmitter$1;
+  options?: DocumentDriveServerOptions$1;
+  synchronizationManager?: ISynchronizationManager$1;
+  listenerManager?: IListenerManager$1;
+  transmitterFactory?: ITransmitterFactory$1;
+  constructor(documentModelModules: DocumentModelModule<any>[]);
+  withStorage(storage: IDriveOperationStorage$1): this;
+  withCache(cache: ICache$1): this;
+  withQueueManager(queueManager: IQueueManager$1): this;
+  withEventEmitter(eventEmitter: IEventEmitter$1): this;
+  withSynchronizationManager(synchronizationManager: ISynchronizationManager$1): this;
+  withListenerManager(listenerManager: IListenerManager$1): this;
+  withTransmitterFactory(transmitterFactory: ITransmitterFactory$1): this;
+  withOptions(options: DocumentDriveServerOptions$1): this;
+  build(): IDocumentDriveServer$1;
+}
+//#endregion
+//#region src/server/event-emitter.d.ts
+declare class DefaultEventEmitter implements IEventEmitter$1 {
+  private emitter;
+  emit<K extends keyof DriveEvents$1>(event: K, ...args: Parameters<DriveEvents$1[K]>): void;
+  on<K extends keyof DriveEvents$1>(event: K, cb: DriveEvents$1[K]): Unsubscribe;
+}
+//#endregion
+//#region src/server/listener/constants.d.ts
+declare const DefaultListenerManagerOptions: {
+  sequentialUpdates: boolean;
+};
+//#endregion
+//#region src/server/listener/listener-manager.d.ts
+declare class ListenerManager implements IListenerManager$1 {
+  static LISTENER_UPDATE_DELAY: number;
+  protected logger: document_model0.ILogger;
+  protected syncManager: ISynchronizationManager$1;
+  protected options: ListenerManagerOptions$1;
+  generateJwtHandler?: (driveUrl: string) => Promise<string>;
+  protected listenerStateByDriveId: Map<string, Map<string, ListenerState$1>>;
+  constructor(syncManager: ISynchronizationManager$1, options?: ListenerManagerOptions$1);
+  setGenerateJwtHandler(handler: (driveUrl: string) => Promise<string>): void;
+  removeJwtHandler(): void;
+  initialize(handler: DriveUpdateErrorHandler$1): Promise<void>;
+  driveHasListeners(driveId: string): boolean;
+  setListener(driveId: string, listener: ServerListener$1): Promise<void>;
+  removeListener(driveId: string, listenerId: string): Promise<boolean>;
+  removeSyncUnits(parentId: string, syncUnits: SynchronizationUnitId$1[]): Promise<void>;
+  updateSynchronizationRevisions(syncUnits: SynchronizationUnit$1[], source: StrandUpdateSource$1, willUpdate?: (listeners: ServerListener$1[]) => void, onError?: (error: Error, driveId: string, listener: ListenerState$1) => void, forceSync?: boolean): Promise<ListenerUpdate$1[]>;
+  updateListenerRevision(listenerId: string, driveId: string, syncId: SynchronizationUnitId$1, listenerRev: number): Promise<void>;
+  triggerUpdate: (immediate?: boolean, source: StrandUpdateSource$1, willUpdate?: ((listeners: ServerListener$1[]) => void) | undefined, onError?: ((error: Error, driveId: string, listener: ListenerState$1) => void) | undefined, maxContinues?: number | undefined) => Promise<ListenerUpdate$1[]>;
+  private _triggerUpdate;
+  private _checkFilter;
+  getListenerSyncUnits(driveId: string, listenerId: string): never[] | Promise<SynchronizationUnit$1[]>;
+  removeDrive(driveId: string): Promise<void>;
+  getStrands(driveId: string, listenerId: string, options?: GetStrandsOptions$1): Promise<StrandUpdate$1[]>;
+  getListenerState(driveId: string, listenerId: string): ListenerState$1;
+  setListenerState(driveId: string, listenerId: string, listenerState: ListenerState$1): void;
+}
+//#endregion
+//#region src/server/listener/util.d.ts
+declare function debounce<T extends unknown[], R>(func: (...args: T) => Promise<R>, delay?: number): (immediate?: boolean, ...args: T) => Promise<R>;
+//#endregion
+//#region src/server/sync-manager.d.ts
+declare class SynchronizationManager implements ISynchronizationManager$1 {
+  private readonly storage;
+  private readonly documentStorage;
+  private readonly cache;
+  private documentModelModules;
+  private readonly eventEmitter?;
+  private syncStatus;
+  private logger;
+  constructor(storage: IDriveOperationStorage$1, documentStorage: IDocumentStorage$1, cache: ICache$1, documentModelModules: DocumentModelModule[], eventEmitter?: IEventEmitter$1 | undefined);
+  getSynchronizationUnits(parentId: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[]): Promise<SynchronizationUnit$1[]>;
+  private getSynchronizationUnitsRevision;
+  getSynchronizationUnitsIds(parentId?: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[]): Promise<SynchronizationUnitQuery$1[]>;
+  getSynchronizationUnit(syncId: SynchronizationUnitId$1): Promise<SynchronizationUnit$1 | undefined>;
+  getOperationData(syncId: SynchronizationUnitId$1, filter: GetStrandsOptions$1): Promise<OperationUpdate$1[]>;
+  private getDocument;
+  private _buildDocument;
+  setDocumentModelModules(modules: DocumentModelModule[]): void;
+  private getDocumentModelModule;
+  getCombinedSyncUnitStatus(syncUnitStatus: SyncUnitStatusObject$1): SyncStatus$1;
+  getSyncStatus(input: string | SynchronizationUnitId$1, scope?: string, branch?: string): SyncStatus$1 | SynchronizationUnitNotFoundError;
+  updateSyncStatus(input: string | SynchronizationUnitId$1, status: Partial<SyncUnitStatusObject$1> | null, error?: Error, scope?: string, branch?: string): void;
+  private initSyncStatus;
+  initializeDriveSyncStatus(driveId: string, drive: DocumentDriveDocument): Promise<void>;
+}
+//#endregion
+//#region src/server/sync-unit-map.d.ts
+/** Separator character used to join synchronization unit key parts */
+type SyncUnitKeySeparator = "|";
+/**
+ * Internal key format used to store synchronization units.
+ * Composed of documentId, scope, and branch joined by the separator.
+ */
+type SyncUnitKey = `${SynchronizationUnitId$1["documentId"]}${SyncUnitKeySeparator}${SynchronizationUnitId$1["scope"]}${SyncUnitKeySeparator}${SynchronizationUnitId$1["branch"]}`;
+/**
+ * A specialized Map implementation for managing synchronization units that uses a "documentId - scope - branch" tuple as key.
+ * It provides methods to store, retrieve, and delete synchronization units of a certain documentId, optionally a scope and a branch.
+ * The implementation uses an internal Map with string keys created by combining documentId, scope, and branch with a separator character.
+ */
+declare class SyncUnitMap<Value> implements ISyncUnitMap$1<Value> {
+  /** Internal storage using concatenated string keys */
+  private internalMap;
+  /** Character used to separate key components */
+  static keySeparator: SyncUnitKeySeparator;
+  /**
+   * Escapes the separator character in a string by prefixing it with a backslash
+   * @param str String to escape
+   */
+  private static escape;
+  /**
+   * Unescapes the separator character in a string by removing the prefix backslash
+   * @param str String to unescape
+   */
+  private static unescape;
+  /**
+   * Creates a composite key from a SynchronizationUnitId
+   * Escapes any separator characters in the components
+   * @param id The synchronization unit identifier
+   * @returns A string key combining documentId, scope, and branch
+   */
+  static buildKey(id: SynchronizationUnitId$1): SyncUnitKey;
+  /**
+   * Parses a composite key back into a SynchronizationUnitId
+   * Unescapes any separator characters in the components
+   * @param key The composite key string
+   * @returns The parsed synchronization unit identifier
+   */
+  static parseKey(key: SyncUnitKey): SynchronizationUnitId$1;
+  /**
+   * Stores a value with the given synchronization unit identifier
+   * @throws Error if any part of the id contains the separator character
+   */
+  set(id: SynchronizationUnitId$1, state: Value): this;
+  /** Retrieves a value by its synchronization unit identifier */
+  get(id: SynchronizationUnitId$1): Value | undefined;
+  /** Checks if a value exists for the given synchronization unit identifier */
+  has(id: SynchronizationUnitId$1): boolean;
+  /** Removes a value by its synchronization unit identifier */
+  delete(id: SynchronizationUnitId$1): boolean;
+  /** Removes all entries from the map */
+  clear(): void;
+  /** Returns the number of entries in the map */
+  get size(): number;
+  /**
+   * Returns an iterator of synchronization unit identifiers
+   * @param filter Optional filter by documentId and scope
+   */
+  keys(filter?: {
+    documentId: string;
+    scope?: string;
+  }): IterableIterator<SynchronizationUnitId$1>;
+  /**
+   * Returns an iterator of stored values
+   * @param filter Optional filter by documentId and scope
+   */
+  values(filter?: {
+    documentId: string;
+    scope?: string;
+  }): IterableIterator<Value>;
+  /**
+   * Returns an iterator of [id, value] pairs
+   * @param filter Optional filter by documentId and scope
+   */
+  entries(filter?: {
+    documentId: string;
+    scope?: string;
+  }): IterableIterator<[SynchronizationUnitId$1, Value]>;
+  /** Makes the map iterable */
+  [Symbol.iterator](): IterableIterator<[SynchronizationUnitId$1, Value]>;
+  /**
+   * Executes a callback for each entry in the map
+   * @param callbackfn Function to execute for each entry
+   * @param thisArg Value to use as 'this' in the callback
+   */
+  forEach(callbackfn: (value: Value, key: SynchronizationUnitId$1, map: ISyncUnitMap$1<Value>) => void, thisArg?: any): void;
+  /**
+   * Removes all entries associated with a specific document
+   * @param documentId The document identifier
+   */
+  deleteByDocumentId(documentId: string): void;
+  /**
+   * Removes all entries for a specific document and scope combination
+   * @param documentId The document identifier
+   * @param scope The scope identifier
+   */
+  deleteByDocumentIdAndScope(documentId: string, scope: string): void;
+  /**
+   * Retrieves all entries associated with a specific document
+   * @param documentId The document identifier
+   * @returns Array of [id, value] pairs
+   */
+  getAllByDocumentId(documentId: string): [SynchronizationUnitId$1, Value][];
+  /**
+   * Retrieves all entries for a specific document and scope combination
+   * @param documentId The document identifier
+   * @param scope The scope identifier
+   * @returns Array of [id, value] pairs
+   */
+  getAllByDocumentIdAndScope(documentId: string, scope: string): [SynchronizationUnitId$1, Value][];
+}
+//#endregion
+//#region src/server/transmitter/factory.d.ts
+declare class TransmitterFactory implements ITransmitterFactory$1 {
+  private readonly listenerManager;
+  constructor(listenerManager: IListenerManager$1);
+  instance(transmitterType: string, listener: ServerListener$1, driveServer: IBaseDocumentDriveServer$1): ITransmitter$1;
+}
+//#endregion
+//#region src/server/transmitter/internal.d.ts
+declare class InternalTransmitter implements ITransmitter$1 {
+  #private;
+  protected drive: IBaseDocumentDriveServer$1;
+  protected processor: IProcessorLegacy$1;
+  protected taskQueueMethod: RunAsap$1<unknown> | null;
+  protected transmitQueue: Promise<ListenerRevision$1[]> | undefined;
+  constructor(drive: IDocumentDriveServer$1, processor: IProcessorLegacy$1, taskQueueMethod?: RunAsap$1<unknown> | null);
+  transmit(strands: StrandUpdate$1[], _source: StrandUpdateSource$1): Promise<ListenerRevision$1[]>;
+  disconnect(): Promise<void>;
+}
+//#endregion
+//#region src/server/transmitter/pull-responder.d.ts
+declare class PullResponderTransmitter implements IPullResponderTransmitter$1 {
+  private logger;
+  private listener;
+  private manager;
+  constructor(listener: ServerListener$1, manager: IListenerManager$1);
+  private static getAuthHeaders;
+  private requestWithAuth;
+  getStrands(options?: GetStrandsOptions$1): Promise<StrandUpdate$1[]>;
+  disconnect(): Promise<void>;
+  processAcknowledge(driveId: string, listenerId: string, revisions: ListenerRevision$1[]): Promise<boolean>;
+  static registerPullResponder(driveId: string, url: string, filter: ListenerFilter, listenerId?: string, manager?: IListenerManager$1): Promise<ServerListener$1["listenerId"]>;
+  static pullStrands(driveId: string, url: string, listenerId: string, options?: GetStrandsOptions$1, manager?: IListenerManager$1): Promise<StrandUpdate$1[]>;
+  static acknowledgeStrands(url: string, listenerId: string, revisions: ListenerRevision$1[], manager?: IListenerManager$1): Promise<void>;
+  /**
+   * This function will only throw if `onError` throws an error (or there is
+   * an unintentionally unhandled error in the pull loop).
+   *
+   * All other errors are caught, logged, and passed to `onError`.
+   *
+   * Because of this, `onError` _may be called multiple times_.
+   *
+   * @returns boolean indicating whether there might be more data to pull
+   */
+  private static executePull;
+  static setupPull(driveId: string, trigger: PullResponderTrigger$1, onStrandUpdate: (strand: StrandUpdate$1, source: StrandUpdateSource$1) => Promise<IOperationResult$1>, onError: (error: Error) => void, onRevisions?: (revisions: ListenerRevisionWithError$1[]) => void, onAcknowledge?: (success: boolean) => void, manager?: IListenerManager$1): CancelPullLoop$1;
+  static createPullResponderTrigger(driveId: string, url: string, options: Pick<RemoteDriveOptions$1, "pullInterval" | "pullFilter">, listenerManager: IListenerManager$1): Promise<PullResponderTrigger$1>;
+  static isPullResponderTrigger(trigger: Trigger): trigger is PullResponderTrigger$1;
+}
+//#endregion
+//#region src/server/transmitter/switchboard-push.d.ts
+declare class SwitchboardPushTransmitter implements ITransmitter$1 {
+  private targetURL;
+  private manager?;
+  private logger;
+  constructor(targetURL: string, manager?: IListenerManager$1);
+  private getAuthHeaders;
+  private requestWithAuth;
+  transmit(strands: StrandUpdate$1[], source: StrandUpdateSource$1): Promise<ListenerRevision$1[]>;
+}
+//#endregion
+//#region src/server/utils.d.ts
+declare function buildRevisionsFilter(strands: StrandUpdate$1[], driveId: string, documentId: string): RevisionsFilter$1;
+declare function buildDocumentRevisionsFilter(document: PHDocument): RevisionsFilter$1;
+declare function filterOperationsByRevision(operations: DocumentOperations, revisions?: RevisionsFilter$1): DocumentOperations;
+declare function isAtRevision(document: PHDocument, revisions?: RevisionsFilter$1): boolean;
+declare function isAfterRevision(document: PHDocument, revisions?: RevisionsFilter$1): boolean;
+declare function compareSyncUnits(a: SynchronizationUnitId$1, b: SynchronizationUnitId$1): boolean;
+declare function resolveCreateDocumentInput<TDocument extends PHDocument>(input: CreateDocumentInput$1<TDocument>): {
+  id: string | undefined;
+  documentType: string;
+  document: TDocument | undefined;
+};
+declare function resolveCreateDocumentInputId(input: CreateDocumentInput$1<PHDocument>): string | undefined;
+declare function resolveCreateDocumentInputDocumentType(input: CreateDocumentInput$1<PHDocument>): string;
+declare function resolveCreateDocumentInputDocument<TDocument extends PHDocument>(input: CreateDocumentInput$1<TDocument>): TDocument | undefined;
+declare function isSharingType(value: string): value is SharingType$1;
+declare function getDriveSharingType(drive: DocumentDriveDocument): SharingType$1;
+//#endregion
+//#region src/read-mode/service.d.ts
+declare class ReadModeService implements IReadModeDriveService$1 {
+  #private;
+  constructor(getDocumentModelModule: GetDocumentModelModule$1);
+  fetchDrive(id: string): Promise<ReadDrive$1 | ReadDriveNotFoundError>;
+  fetchDocument<TState extends PHBaseState = PHBaseState>(driveId: string, documentId: string, documentType: string): Promise<PHDocument<TState> | DocumentModelNotFoundError | ReadDriveNotFoundError | ReadDocumentNotFoundError>;
+  addReadDrive(url: string, options?: ReadDriveOptions$1): Promise<void>;
+  getReadDrives(): Promise<string[]>;
+  getReadDrive(id: string): Promise<ReadDrive$1 | ReadDriveNotFoundError>;
+  getReadDriveBySlug(slug: string): Promise<ReadDrive$1 | ReadDriveSlugNotFoundError>;
+  getReadDriveContext(id: string): Promise<ReadDriveContext$1 | ReadDriveNotFoundError>;
+  deleteReadDrive(id: string): Promise<ReadDriveNotFoundError | undefined>;
+}
+//#endregion
+//#region src/utils/default-drives-manager.d.ts
+declare class DefaultDrivesManager implements IDefaultDrivesManager$1 {
+  private server;
+  private delegate;
+  private defaultRemoteDrives;
+  private removeOldRemoteDrivesConfig;
+  constructor(server: IBaseDocumentDriveServer$1 | (IBaseDocumentDriveServer$1 & IReadModeDriveServer$1), delegate: IServerDelegateDrivesManager$1, options?: Pick<DocumentDriveServerOptions$1, "defaultDrives">);
+  getDefaultRemoteDrives(): Map<string, DefaultRemoteDriveInfo$1>;
+  private deleteDriveById;
+  private preserveDrivesById;
+  private removeDrivesById;
+  private detachDrivesById;
+  removeOldremoteDrives(): Promise<void>;
+  setAllDefaultDrivesAccessLevel(level: RemoteDriveAccessLevel$1): Promise<void>;
+  setDefaultDriveAccessLevel(url: string, level: RemoteDriveAccessLevel$1): Promise<void>;
+  initializeDefaultRemoteDrives(defaultDrives?: DefaultRemoteDriveInfo$1[]): Promise<void>;
+}
+//#endregion
+//#region src/utils/errors.d.ts
+declare class AbortError extends Error {
+  constructor(message?: string);
+}
+declare const isAbortError: (error: unknown) => boolean;
+//#endregion
+//#region src/utils/gql-transformations.d.ts
+type ResponseForDrive = {
+  id: string;
+  slug: string;
+  meta: Record<string, unknown> | undefined;
+  name: string;
+  icon: string | undefined;
+  graphqlEndpoint?: string;
+};
+declare function responseForDrive(drive: DocumentDriveDocument, graphqlEndpoint?: string): ResponseForDrive;
+type PHDocumentGQL = Omit<PHDocumentHeader, "revision"> & {
+  id: string;
+  revision: number;
+  /**
+   * @deprecated Use createdAtUtcIso instead
+   */
+  createdAt: string;
+  /**
+   * @deprecated Use lastModifiedAtUtcIso instead
+   */
+  lastModified: string;
+  __typename: string;
+  state: unknown;
+  initialState: unknown;
+  stateJSON: unknown;
+  operations: Operation[];
+  nodeName?: string;
+};
+declare function responseForDocument(document: PHDocument, typeName: string, nodeName?: string): PHDocumentGQL;
+//#endregion
+//#region src/utils/graphql.d.ts
+declare function requestGraphql<T>(url: string, document: string, variables?: Record<string, unknown>, headers?: Record<string, string>): Promise<GraphQLResult$1<T>>;
+declare function generateDocumentStateQueryFields(documentModelState: DocumentModelGlobalState, prefix: string, options?: BuildSchemaOptions & ParseOptions): string;
+declare function requestPublicDriveWithTokenFromReactor(url: string, server: IBaseDocumentDriveServer$1): Promise<DriveInfo$1>;
+declare function requestPublicDrive(url: string, headers?: Record<string, string>): Promise<DriveInfo$1>;
+declare function requestPublicDriveFromReactor(url: string, headers?: Record<string, string>): Promise<DriveInfo$1>;
+declare function fetchDocument<TState extends PHBaseState = PHBaseState>(url: string, documentId: string, documentModelModule: DocumentModelModule<TState>): Promise<GraphQLResult$1<{
+  document: DocumentGraphQLResult$1<TState>;
+}>>;
+//#endregion
+//#region src/utils/migrations.d.ts
+declare function migrateDocumentOperationSignatures(document: PHDocument): PHDocument | undefined;
+declare function migrateLegacyOperationSignature<TGlobalState, TLocalState>(operation: Operation): Operation;
+//#endregion
+//#region src/utils/misc.d.ts
+declare function isDocumentDrive(document: PHDocument): document is DocumentDriveDocument;
+declare function mergeOperations(currentOperations: DocumentOperations, newOperations: Operation[]): DocumentOperations;
+declare function isNoopUpdate(operation: Operation, latestOperation?: Operation): boolean;
+declare function isBefore(dateA: Date | string, dateB: Date | string): boolean;
+declare function operationsToRevision(operations: Pick<Operation, "index">[] | undefined): ListenerRevision$1["revision"];
+/**
+ * Converts a string to PascalCase
+ * @param {string} str - The input string to convert
+ * @returns {string} The string in PascalCase format
+ *
+ * Examples:
+ * "hello world" -> "HelloWorld"
+ * "hello-world" -> "HelloWorld"
+ * "hello_world" -> "HelloWorld"
+ * "helloWorld" -> "HelloWorld"
+ */
+declare const toPascalCase: typeof pascalCase;
+//#endregion
+//#region src/utils/run-asap.d.ts
+declare const useMessageChannel: Error | ((task: Task$1) => () => void);
+declare const usePostMessage: Error | ((task: Task$1) => () => void);
+declare const useSetImmediate: Error | ((task: Task$1) => () => void);
+declare const useSetTimeout: (task: Task$1) => () => void;
+declare function runAsap<T = void>(task: Task$1<T>): AbortTask$1;
+declare function runAsapAsync<T = void>(task: Task$1<Promise<T>>, queueMethod?: RunAsap$1<void>): Promise<T>;
+//#endregion
+//#region src/utils/test.d.ts
+declare const baseDocumentModels: DocumentModelModule<any>[];
+declare function expectUUID(expect: ExpectStatic): unknown;
+declare function expectOperationId(expect: ExpectStatic): unknown;
+declare function expectUTCTimestamp(expect: ExpectStatic): unknown;
+declare function buildOperation<TDocument extends PHDocument>(reducer: Reducer<any>, document: TDocument, action: Action, index?: number): Operation;
+declare function buildOperations<TDocument extends PHDocument>(reducer: Reducer<any>, document: TDocument, actions: Array<Action>): Operation[];
+declare function buildOperationAndDocument<TDocument extends PHDocument>(reducer: Reducer<any>, document: TDocument, action: Action, index?: number): {
+  document: TDocument;
+  operation: Operation;
+};
+declare class BasicClient<TDocument extends PHDocument = PHDocument> {
+  private server;
+  private driveId;
+  private documentId;
+  private document;
+  private reducer;
+  private unsyncedOperations;
+  constructor(server: BaseDocumentDriveServer$1, driveId: string, documentId: string, document: TDocument, reducer: Reducer<any>);
+  getDocument(): TDocument;
+  clearUnsyncedOperations(): void;
+  pushOperationsToServer(): Promise<document_drive0.IOperationResult>;
+  syncDocument(): Promise<TDocument>;
+  dispatchDocumentAction(action: Action): {
+    document: TDocument;
+    operation: Operation;
+  };
+}
+declare class DriveBasicClient<TDocument extends PHDocument = PHDocument> {
+  private server;
+  private driveId;
+  private document;
+  private reducer;
+  private unsyncedOperations;
+  constructor(server: IDocumentDriveServer$1, driveId: string, document: TDocument, reducer: Reducer<any>);
+  getDocument(): TDocument;
+  getUnsyncedOperations(): Operation[];
+  setUnsyncedOperations(operations: Operation[]): void;
+  clearUnsyncedOperations(): void;
+  pushOperationsToServer(): Promise<document_drive0.IOperationResult<PHDocument>>;
+  syncDocument(): Promise<TDocument>;
+  dispatchDriveAction(action: Action): {
+    document: TDocument;
+    operation: Operation;
+  };
+}
+declare const fakeAction: (params: Partial<Action> & {
+  index?: number;
+  hash?: string;
+  skip?: number;
+}) => Action;
+/**
+ * Creates a default base state with the required auth and document properties
+ * @param global - The global state
+ * @param local - The local state
+ */
+declare function createBaseState<TGlobal, TLocal>(global: TGlobal, local: TLocal): PHBaseState & {
+  global: TGlobal;
+  local: TLocal;
+};
+//#endregion
+export { AbortError, AbortTask, ActionJob, AddOperationOptions, AddRemoteDriveStatus, BaseDocumentDriveServer, BaseJob, BasicClient, BrowserStorage, CacheStorageManager, CancelPullLoop, ConflictOperationError, Constructor, CreateDocumentInput, CreateDocumentInputWithDocument, CreateDocumentInputWithDocumentType, CreateDocumentInputWithHeader, CreateListenerInput, DefaultDrivesManager, DefaultEventEmitter, DefaultListenerManagerOptions, DefaultRemoteDriveInfo, DefaultRemoteDriveInput, DocumentAlreadyExistsError, DocumentAlreadyExistsReason, DocumentDriveServer, DocumentDriveServerConstructor, DocumentDriveServerMixin, DocumentDriveServerOptions, DocumentGraphQLResult, DocumentJob, DocumentModelNotFoundError, DocumentNotFoundError, DriveBasicClient, DriveEvents, DriveInfo, DriveInput, DriveOperationResult, DriveState, DriveUpdateErrorHandler, ErrorStatus, EventQueueManager, ExtractProcessorSchema, ExtractProcessorSchemaOrSelf, GetDocumentModelModule, GetDocumentOptions, GetStrandsOptions, GraphQLResult, HashAlgorithmsLegacy, IBaseDocumentDriveServer, IBaseRelationalDbLegacy, ICache, ICacheStorage, ICacheStorageManager, IDefaultDrivesManager, IDocumentAdminStorage, IDocumentCache, IDocumentDriveServer, IDocumentOperationStorage, IDocumentStorage, IDriveOperationStorage, IEventEmitter, IJob, IJobQueue, IListenerManager, IOperationResult, IProcessorHostModuleLegacy, IProcessorLegacy, IProcessorManagerLegacy, IPullResponderTransmitter, IQueue, IQueueManager, IReadModeDriveServer, IReadModeDriveService, IRelationalDbLegacy, IRelationalDbProcessorLegacy, IRelationalQueryBuilderLegacy, IRelationalQueryMethods, IServerDelegate, IServerDelegateDrivesManager, IStorageUnit, IStorageUnitFilter, IStorageUnitStorage, ISyncUnitMap, ISynchronizationManager, ITransmitter, ITransmitterFactory, InMemoryCache, InternalOperationUpdate, InternalTransmitter, InternalTransmitterService, InternalTransmitterUpdate, Job, JobId, LRUCacheStorage, LRUCacheStorageOptions, LegacyCreateDocumentInput, ListenerManager, ListenerManagerOptions, ListenerRevision, ListenerRevisionWithError, ListenerState, ListenerStatus, ListenerUpdate, MemoryQueue, MemoryStorage, MissingOperationError, Mixin, OperationError, OperationJob, OperationUpdate, OperationUpdateGraphQL, PHDocumentGQL, PartialRecord, ProcessorFactoryLegacy, ProcessorManagerLegacy, ProcessorRecordLegacy, PullResponderTransmitter, PullResponderTrigger, PullStrandsGraphQL, PullSyncStatus, PushSyncStatus, QueueEvents, ReactorBuilder, ReadDocumentNotFoundError, ReadDrive, ReadDriveContext, ReadDriveError, ReadDriveNotFoundError, ReadDriveOptions, ReadDriveSlugNotFoundError, ReadDrivesListener, ReadDrivesListenerUnsubscribe, ReadModeDriveServerMixin, ReadModeServer, ReadModeService, RedisCache, RelationalDbProcessorClassLegacy, RelationalDbProcessorFilterLegacy, RelationalDbProcessorLegacy, RemoteDriveAccessLevel, RemoteDriveOptions, RemoveDriveStrategy, RemoveOldRemoteDrivesOption, ResolvedStorageUnitFilter, RevisionsFilter, RunAsap, ServerListener, ServerTransmitterType, SharingType, StrandUpdate, StrandUpdateGraphQL, StrandUpdateSource, SwitchboardPushTransmitter, SyncStatus, SyncUnitMap, SyncUnitStatusObject, SynchronizationManager, SynchronizationUnit, SynchronizationUnitId, SynchronizationUnitMap, SynchronizationUnitNotFoundError, SynchronizationUnitQuery, SyncronizationUnitState, Task, TransmitterFactory, UpdateStatus, baseDocumentModels, buildDocumentRevisionsFilter, buildOperation, buildOperationAndDocument, buildOperations, buildRevisionsFilter, compareSyncUnits, createBaseState, createNamespacedDbLegacy, createNamespacedQueryBuilderLegacy, createRelationalDbLegacy, debounce, decodeDocumentIdFromPath, encodeDocumentIdForPath, expectOperationId, expectUTCTimestamp, expectUUID, fakeAction, fetchDocument, filterOperationsByRevision, generateDocumentStateQueryFields, getDriveSharingType, gql, hasBase64SpecialChars, hashNamespaceLegacy, isAbortError, isActionJob, isAfterRevision, isAtRevision, isBefore, isDocumentDrive, isDocumentJob, isNoopUpdate, isOperationJob, isRelationalDbProcessor, isSharingType, isUUID, mergeOperations, migrateDocumentOperationSignatures, migrateLegacyOperationSignature, operationsToRevision, relationalDbToQueryBuilderLegacy, requestGraphql, requestPublicDrive, requestPublicDriveFromReactor, requestPublicDriveWithTokenFromReactor, resolveCreateDocumentInput, resolveCreateDocumentInputDocument, resolveCreateDocumentInputDocumentType, resolveCreateDocumentInputId, resolveStorageUnitsFilter, resolveStorageUnitsFilterComponent, responseForDocument, responseForDrive, runAsap, runAsapAsync, setIntersection, setUnion, toPascalCase, trimResultingState, useMessageChannel, usePostMessage, useSetImmediate, useSetTimeout };
 //# sourceMappingURL=index.d.ts.map