@powerhousedao/shared 6.1.0-dev.15 → 6.1.0-dev.17

package/dist/{actions-BqyQ1_K7.d.ts → types-CC6ib3_2.d.ts}

@@ -1,58 +1,9 @@
-import { f as IAnalyticsStore } from "./types-BFDlQkXZ.js";
+import { f as IAnalyticsStore } from "./types-C1in4fl3.js";
 import { z } from "zod";
 import { Draft } from "mutative";
 import { OperationWithContext } from "@powerhousedao/shared/document-model";
 import { FC, ReactNode } from "react";
 
-//#region document-model/signatures.d.ts
-/**
- * A signature of an action.
- *
- * This will be refactored in a future release.
- */
-type Signature = [string, string, string, string, string];
-/**
- * A user action signer.
- */
-type UserActionSigner = {
-  address: string;
-  networkId: string;
-  chainId: number;
-};
-/**
- * An app action signer.
- */
-type AppActionSigner = {
-  name: string;
-  key: string;
-};
-/**
- * An action signer.
- */
-type ActionSigner = {
-  user: UserActionSigner;
-  app: AppActionSigner;
-  signatures: Signature[];
-};
-/**
- * Information to verify the document creator.
- */
-type PHDocumentSignatureInfo = {
-  /**
-   * The public key of the document creator.
-   **/
-  publicKey: JsonWebKey; /** The nonce that was appended to the message to create the signature. */
-  nonce: string;
-};
-/**
- * Configuration for hashing document state in operations.
- */
-type HashConfig = {
-  /** The hashing algorithm to use (e.g., "sha1", "sha256") */algorithm: string; /** The encoding format for the hash output (e.g., "base64", "hex") */
-  encoding: string; /** Optional algorithm-specific parameters */
-  params?: Record<string, unknown>;
-};
-//#endregion
 //#region processors/constants.d.ts
 declare const PROCESSOR_APPS: readonly ["connect", "switchboard"];
 declare const DEFAULT_RELATIONAL_PROCESSOR_DB_NAME = "relational-db";
@@ -18618,195 +18569,971 @@ declare class Command<T> {
   execute(): Promise<T>;
 }
 //#endregion
-//#region processors/types.d.ts
-type ProcessorDispatchResult = {
-  id: string;
-  status: string;
-};
-interface IProcessorDispatch {
-  execute(docId: string, branch: string, actions: Action[], signal?: AbortSignal, meta?: Record<string, unknown>): Promise<ProcessorDispatchResult>;
-}
-interface IProcessorHostModule {
-  analyticsStore: IAnalyticsStore;
-  relationalDb: IRelationalDb;
-  processorApp: ProcessorApp;
-  dispatch: IProcessorDispatch;
-  getReadModel<T>(name: string): T;
-  config?: Map<string, unknown>;
-}
+//#region document-model/signatures.d.ts
 /**
- * Filter for matching operations to processors.
- * All fields are optional arrays - when provided, operations must match at least one value in each specified field.
- * When a field is undefined or empty, it matches all values for that field.
+ * A signature of an action.
+ *
+ * This will be refactored in a future release.
  */
-type ProcessorFilter = {
-  documentType?: string[];
-  scope?: string[];
-  branch?: string[];
-  documentId?: string[];
-};
+type Signature = [string, string, string, string, string];
 /**
- * Describes an object that can process operations.
+ * A user action signer.
  */
-interface IProcessor {
-  /**
-   * Processes a list of operations with context.
-   * Called when operations match this processor's filter.
-   */
-  onOperations(operations: OperationWithContext[]): Promise<void>;
-  /**
-   * Called when the processor is disconnected.
-   * Used to clean up any resources allocated during processor creation.
-   */
-  onDisconnect(): Promise<void>;
-}
+type UserActionSigner = {
+  address: string;
+  networkId: string;
+  chainId: number;
+};
 /**
- * Relates a processor to its filter configuration.
+ * An app action signer.
  */
-type ProcessorRecord = {
-  processor: IProcessor;
-  filter: ProcessorFilter;
-  startFrom?: "beginning" | "current";
+type AppActionSigner = {
+  name: string;
+  key: string;
 };
 /**
- * A factory function that creates processor records for a given drive.
- * Called once per drive when the drive is first detected or when the factory is registered.
+ * An action signer.
  */
-type ProcessorFactory = (driveHeader: PHDocumentHeader, processorApp?: ProcessorApp) => Promise<ProcessorRecord[]> | ProcessorRecord[];
-/** Takes a processor host module and builds processor factories using its context */
-type ProcessorFactoryBuilder = (module: IProcessorHostModule) => Promise<ProcessorFactory> | ProcessorFactory;
-type ProcessorStatus = "active" | "errored";
-type TrackedProcessor = {
-  processorId: string;
-  factoryId: string;
-  driveId: string;
-  processorIndex: number;
-  record: ProcessorRecord;
-  lastOrdinal: number;
-  status: ProcessorStatus;
-  lastError: string | undefined;
-  lastErrorTimestamp: Date | undefined;
-  retry: () => Promise<void>;
+type ActionSigner = {
+  user: UserActionSigner;
+  app: AppActionSigner;
+  signatures: Signature[];
 };
 /**
- * Manages processor creation and destruction based on drive operations.
+ * Information to verify the document creator.
  */
-interface IProcessorManager {
-  /**
-   * Registers a processor factory.
-   * Immediately creates processors for all existing drives.
-   */
-  registerFactory(identifier: string, factory: ProcessorFactory): Promise<void>;
-  /**
-   * Unregisters a processor factory and disconnects all processors it created.
-   */
-  unregisterFactory(identifier: string): Promise<void>;
-  /**
-   * Gets a tracked processor by its ID.
-   */
-  get(processorId: string): TrackedProcessor | undefined;
+type PHDocumentSignatureInfo = {
   /**
-   * Gets all tracked processors.
-   */
-  getAll(): TrackedProcessor[];
-}
-type ProcessorApp = (typeof PROCESSOR_APPS)[number];
-type ProcessorApps = readonly ProcessorApp[];
-//#endregion
-//#region processors/relational/types.d.ts
-type IRelationalQueryMethods = "selectFrom" | "selectNoFrom" | "with" | "withRecursive";
-type IRelationalQueryBuilder<Schema = unknown> = Pick<QueryCreator<Schema>, IRelationalQueryMethods> & {
-  withSchema: (schema: string) => IRelationalQueryBuilder<Schema>;
+   * The public key of the document creator.
+   **/
+  publicKey: JsonWebKey; /** The nonce that was appended to the message to create the signature. */
+  nonce: string;
 };
-type HashAlgorithms = "fnv1a";
-type IBaseRelationalDb<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 IRelationalDb<Schema = unknown> = IBaseRelationalDb<Schema> & {
-  createNamespace<NamespaceSchema>(namespace: string): Promise<IRelationalDb<ExtractProcessorSchemaOrSelf<NamespaceSchema>>>;
-  queryNamespace<NamespaceSchema>(namespace: string): IRelationalQueryBuilder<NamespaceSchema>;
+ * Configuration for hashing document state in operations.
+ */
+type HashConfig = {
+  /** The hashing algorithm to use (e.g., "sha1", "sha256") */algorithm: string; /** The encoding format for the hash output (e.g., "base64", "hex") */
+  encoding: string; /** Optional algorithm-specific parameters */
+  params?: Record<string, unknown>;
 };
-type ExtractProcessorSchemaOrSelf<TProcessor> = TProcessor extends RelationalDbProcessor<infer TSchema> ? TSchema : TProcessor;
-type RelationalDbProcessorClass<TSchema> = typeof RelationalDbProcessor<TSchema>;
-interface IRelationalDbProcessor<TDatabaseSchema = unknown> extends IProcessor {
-  namespace: string;
-  query: IRelationalQueryBuilder<TDatabaseSchema>;
-  filter: ProcessorFilter;
-  initAndUpgrade(): Promise<void>;
-}
-declare const IS_RELATIONAL_DB_PROCESSOR: unique symbol;
+//#endregion
+//#region document-model/state.d.ts
 /**
- * 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.
+ * Creates a default PHAuthState
  */
-declare abstract class RelationalDbProcessor<TDatabaseSchema = unknown> implements IRelationalDbProcessor<TDatabaseSchema> {
-  protected _namespace: string;
-  protected _filter: ProcessorFilter;
-  protected relationalDb: IRelationalDb<TDatabaseSchema>;
-  constructor(_namespace: string, _filter: ProcessorFilter, relationalDb: IRelationalDb<TDatabaseSchema>);
-  static [IS_RELATIONAL_DB_PROCESSOR]: boolean;
-  /**
-   * 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: RelationalDbProcessorClass<Schema>, driveId: string, db: IRelationalDb<any>): IRelationalQueryBuilder<Schema>;
-  /**
-   * Processes a list of operations with context.
-   * Called when operations match this processor's filter.
-   */
-  abstract onOperations(operations: OperationWithContext[]): Promise<void>;
-  /**
-   * Returns the filter for the processor.
-   * This method can be overridden by derived classes to provide a custom filter.
-   */
-  get filter(): ProcessorFilter;
-  /**
-   * Returns the namespace used by the processor.
-   */
-  get namespace(): string;
-  get query(): IRelationalQueryBuilder<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>;
-  /**
-   * Called when the processor is disconnected.
-   * This method is meant to be overridden by subclasses to clean up resources.
-   */
-  abstract onDisconnect(): Promise<void>;
-}
-//#endregion
-//#region processors/relational/utils.d.ts
+declare function defaultAuthState(): PHAuthState;
 /**
- * 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.
+ * Creates a default PHDocumentState
  */
-declare function hashNamespace(str: string, length?: number): string;
+declare function defaultDocumentState(): PHDocumentState;
 /**
- * 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.
+ * Creates a default PHBaseState with auth and document properties
  */
-declare function createRelationalDb<Schema>(baseDb: IBaseRelationalDb<Schema>, baseOptions?: NamespaceOptions): IRelationalDb<Schema>;
-type NamespaceOptions = {
-  hashNamespace?: boolean;
-};
-declare function createNamespacedDb<Schema>(db: IBaseRelationalDb<any>, namespace: string, options?: NamespaceOptions): Promise<IRelationalDb<Schema>>;
-declare function createNamespacedQueryBuilder<Schema>(db: IBaseRelationalDb<any>, namespace: string, options?: NamespaceOptions): IRelationalQueryBuilder<Schema>;
+declare function defaultBaseState(): PHBaseState;
 /**
- * Returns a query builder for a RelationalDb instance.
- * @param query The RelationalDb instance to convert.
- * @returns The IRelationalQueryBuilder instance.
+ * Creates a PHAuthState with the given properties
+ */
+declare function createAuthState(auth?: Partial<PHAuthState>): PHAuthState;
+/**
+ * Creates a PHDocumentState with the given properties
+ */
+declare function createDocumentState(document?: Partial<PHDocumentState>): PHDocumentState;
+/**
+ * Creates a PHBaseState with the given auth and document properties
+ */
+declare function createBaseState(auth?: Partial<PHAuthState>, document?: Partial<PHDocumentState>): PHBaseState;
+/**
+ * The document state of the document.
+ */
+type PHDocumentState = {
+  /**
+   * The current document model schema version of the document. This is used
+   * with the UPGRADE_DOCUMENT operation to specify the DocumentModelModule
+   * version to use for reducer execution.
+   */
+  version: number; /** Hash configuration for operation state verification */
+  hash: HashConfig; /** True if and only if the document has been deleted */
+  isDeleted?: boolean; /** The timestamp when the document was deleted, in UTC ISO format */
+  deletedAtUtcIso?: string; /** Optional: who deleted the document */
+  deletedBy?: string; /** Optional: reason for deletion */
+  deletionReason?: string;
+};
+/**
+ * The authentication state of the document.
+ *
+ * This has yet to be implemented.
+ */
+type PHAuthState = {};
+/**
+ * The base state of the document.
+ */
+type PHBaseState = {
+  /** Carries authentication information. */auth: PHAuthState; /** Carries information about the document. */
+  document: PHDocumentState;
+};
+declare function defaultGlobalState(): DocumentModelGlobalState;
+declare function defaultLocalState(): DocumentModelLocalState;
+declare function defaultPHState(): DocumentModelPHState;
+declare function createGlobalState(state?: Partial<DocumentModelGlobalState>): DocumentModelGlobalState;
+declare function createLocalState(state?: Partial<DocumentModelLocalState>): DocumentModelLocalState;
+declare function createState(baseState?: Partial<PHBaseState>, globalState?: Partial<DocumentModelGlobalState>, localState?: Partial<DocumentModelLocalState>): DocumentModelPHState;
+//#endregion
+//#region document-model/operations.d.ts
+declare function setNameOperation<TDocument extends PHDocument>(document: TDocument, input: {
+  name: string;
+}): TDocument & {
+  header: {
+    name: string;
+    id: string;
+    sig: PHDocumentSignatureInfo;
+    documentType: string;
+    createdAtUtcIso: string;
+    slug: string;
+    branch: string;
+    revision: {
+      [scope: string]: number;
+    };
+    lastModifiedAtUtcIso: string;
+    protocolVersions?: {
+      [key: string]: number;
+    };
+    meta?: PHDocumentMeta;
+  };
+};
+declare function setPreferredEditorOperation<TDocument extends PHDocument>(document: TDocument, input: {
+  preferredEditor: string | null;
+}): TDocument;
+declare function undoOperation<TDocument extends PHDocument>(document: TDocument, action: Action, skip: number): {
+  document: TDocument;
+  action: Action;
+  skip: number;
+  reuseLastOperationIndex: boolean;
+};
+/**
+ * V2 of undoOperation for protocol version 2+.
+ * Key differences from undoOperation:
+ * - Never reuses operation index (always increments)
+ * - Always sets skip=1 (consecutive NOOPs are handled during rebuild/GC)
+ * - No complex skip calculation - simpler model where each UNDO is independent
+ */
+declare function undoOperationV2<TDocument extends PHDocument>(document: TDocument, action: Action, skip: number): {
+  document: TDocument;
+  action: Action;
+  skip: number;
+  reuseLastOperationIndex: false;
+};
+declare function redoOperation<TDocument extends PHDocument>(document: TDocument, action: Action, skip: number): {
+  document: TDocument;
+  action: Action;
+  skip: number;
+  reuseLastOperationIndex: boolean;
+};
+declare function loadStateOperation<TState extends PHBaseState>(document: PHDocument<TState>, action: LoadStateActionInput): PHDocument<TState>;
+/**
+ * An operation that was applied to a {@link BaseDocument}.
+ *
+ * @remarks
+ * Wraps an action with an index, to be added to the operations history of a Document.
+ * The `index` field is used to keep all operations in order and enable replaying the
+ * document's history from the beginning. Note that indices and skips are relative to
+ * a specific reactor. Example below:
+ *
+ * For (index, skip, ts, action)
+ * A - [(0, 0, 1, "A0"), (1, 0, 2, "A1")]
+ * B - [(0, 0, 0, "B0"), (1, 0, 3, "B1")]
+ * ...
+ * B gets A's Operations Scenario:
+ * B' - [(0, 0, 0, "B0"), (1, 0, 3, "B1"), (2, 1, 1, "A0"), (3, 0, 2, "A1"), (4, 0, 3, "B1")]
+ * Then A needs to end up with:
+ * A' - [(0, 0, 1, "A0"), (1, 0, 2, "A1"), (2, 2, 0, "B0"), (3, 0, 1, "A0"), (4, 0, 2, "A1"), (5, 0, 3, "B1")]
+ * So that both A and B end up with the stream of actions (action):
+ * [("B0"), ("A0"), ("A1"), ("B1")]
+ *
+ * @typeParam A - The type of the action.
+ */
+type Operation = {
+  /**
+   * This is a stable id, derived from various document and action properties
+   * in deriveOperationId().
+   *
+   * It _cannot_ be an arbitrary string.
+   *
+   * It it also not unique per operation, as reshuffled operations will keep'
+   * the same id they had before they were reshuffled. This means that the
+   * IOperationStore may have multiple operations with the same operation id.
+   **/
+  id: string; /** Position of the operation in the history. This is relative to a specific reactor -- they may not all agree on this value. */
+  index: number; /** The number of operations skipped with this Operation. This is relative to a specific reactor -- they may not all agree on this value. */
+  skip: number; /** Timestamp of when the operation was added */
+  timestampUtcMs: string; /** Hash of the resulting document data after the operation */
+  hash: string; /** Error message for a failed action */
+  error?: string; /** The resulting state after the operation */
+  resultingState?: string;
+  /**
+   * The action that was applied to the document to produce this operation.
+   */
+  action: Action;
+};
+/**
+ * The operations history of the document by scope.
+ *
+ * This will be removed in a future release.
+ *
+ * TODO: Type should be Partial<Record<string, Operation[]>>,
+ * but that is a breaking change for codegen + external doc models.
+ */
+type DocumentOperations = Record<string, Operation[]>;
+type OperationContext = {
+  documentId: string;
+  documentType: string;
+  scope: string;
+  branch: string;
+  resultingState?: string;
+  ordinal: number;
+};
+type OperationWithContext$1 = {
+  operation: Operation;
+  context: OperationContext;
+};
+//#endregion
+//#region document-model/documents.d.ts
+/** Meta information about the document. */
+type PHDocumentMeta = {
+  /** The preferred editor for the document. */preferredEditor?: string;
+};
+/**
+ * The header of a document.
+ */
+type PHDocumentHeader = {
+  /**
+   * The id of the document.
+   *
+   * This is a Ed25519 signature and is immutable.
+   **/
+  id: string;
+  /**
+   * Information to verify the document creator.
+   *
+   * This is immutable.
+   **/
+  sig: PHDocumentSignatureInfo;
+  /**
+   * The type of the document.
+   *
+   * This is used as part of the signature payload and thus, cannot be changed
+   * after the document header has been created.
+   **/
+  documentType: string;
+  /**
+   * The timestamp of the creation date of the document, in UTC ISO format.
+   *
+   * This is used as part of the signature payload and thus, cannot be changed
+   * after the document header has been created.
+   **/
+  createdAtUtcIso: string; /** The slug of the document. */
+  slug: string; /** The name of the document. */
+  name: string; /** The branch of this document. */
+  branch: string;
+  /**
+   * The revision of each scope of the document. This object is updated every
+   * time any _other_ scope is updated.
+   */
+  revision: {
+    [scope: string]: number;
+  };
+  /**
+   * The timestamp of the last change in the document, in UTC ISO format.
+   **/
+  lastModifiedAtUtcIso: string;
+  /**
+   * This is a map from protocol name to version. A protocol can be any set of
+   * rules that are applied to the document.
+   *
+   * Examples of protocols include:
+   *
+   * - "base-reducer"
+   */
+  protocolVersions?: {
+    [key: string]: number;
+  }; /** Meta information about the document. */
+  meta?: PHDocumentMeta;
+};
+/**
+ * The base type of a document model.
+ *
+ * @remarks
+ * This type is extended by all Document models.
+ *
+ * @typeParam TState - The type of the document state.
+ */
+type PHDocument<TState extends PHBaseState = PHBaseState> = {
+  /** The header of the document. */header: PHDocumentHeader; /** The document model specific state. */
+  state: TState;
+  /**
+   * The initial state of the document, enabling replaying operations.
+   *
+   * This will be removed in a future release.
+   */
+  initialState: TState;
+  /**
+   * The operations history of the document.
+   *
+   * This will be removed in a future release.
+   */
+  operations: DocumentOperations;
+  /**
+   * A list of undone operations
+   *
+   * This will be removed in a future release.
+   */
+  clipboard: Operation[];
+};
+declare function isNoopOperation<TOp extends {
+  type: string;
+  skip: number;
+  hash: string;
+}>(op: Partial<TOp>): boolean;
+declare function isUndoRedo(action: Action): action is UndoRedoAction;
+declare function isUndo(action: Action): action is UndoAction;
+declare function isDocumentAction(action: Action): action is DocumentAction;
+/**
+ * Creates a new document. When `documentType` is given the header is stamped
+ * with it and the document-scope operations are seeded.
+ */
+declare function baseCreateDocument<TState extends PHBaseState = PHBaseState>(createState: CreateState<TState>, initialState?: Partial<TState>, documentType?: string): PHDocument<TState>;
+declare function hashDocumentStateForScope(document: {
+  state: {
+    [key: string]: unknown;
+  };
+}, scope?: string): string;
+declare function readOnly<T>(value: T): Readonly<T>;
+/**
+ * Maps skipped operations in an array of operations.
+ * Skipped operations are operations that are ignored during processing.
+ * @param operations - The array of operations to map.
+ * @param skippedHeadOperations - The number of operations to skip at the head of the array of operations.
+ * @returns An array of mapped operations with ignore flag indicating if the operation is skipped.
+ * @throws Error if the operation index is invalid and there are missing operations.
+ */
+declare function mapSkippedOperations(operations: Operation[], skippedHeadOperations?: number): MappedOperation[];
+/**
+ * V2 version of mapSkippedOperations for protocol version 2+.
+ * In V2, all NOOPs have skip=1 and consecutive NOOPs form chains.
+ * N consecutive NOOPs at any point skip N preceding content operations.
+ *
+ * Algorithm: Process from end to start
+ * - When hitting a NOOP: increment chain length, mark as ignored
+ * - When hitting a non-NOOP:
+ *   - If chain > 0: decrement chain, mark as ignored (this op was undone)
+ *   - If chain == 0: mark as not ignored (apply this op)
+ */
+declare function mapSkippedOperationsV2(operations: Operation[]): MappedOperation[];
+/**
+ * V2 garbage collect that returns only operations that should be applied for state.
+ * Uses the V2 model where consecutive NOOPs form chains.
+ * Unlike V1 garbageCollect, this preserves ALL operations but marks which to apply.
+ */
+declare function garbageCollectV2<TOpIndex extends OperationIndex>(sortedOperations: TOpIndex[]): TOpIndex[];
+declare function sortMappedOperations(operations: DocumentOperationsIgnoreMap): MappedOperation[];
+declare function replayDocument<TState extends PHBaseState = PHBaseState>(initialState: TState, operations: DocumentOperations, reducer: Reducer<TState>, header: PHDocumentHeader, dispatch?: SignalDispatch, skipHeaderOperations?: SkipHeaderOperations, options?: ReplayDocumentOptions): PHDocument<TState>;
+declare function parseResultingState<TState>(state: string | null | undefined): TState;
+declare enum IntegrityIssueType {
+  UNEXPECTED_INDEX = "UNEXPECTED_INDEX"
+}
+declare enum IntegrityIssueSubType {
+  DUPLICATED_INDEX = "DUPLICATED_INDEX",
+  MISSING_INDEX = "MISSING_INDEX"
+}
+type IntegrityIssue = {
+  operation: OperationIndex;
+  issue: IntegrityIssueType;
+  category: IntegrityIssueSubType;
+  message: string;
+};
+type Reshuffle = (startIndex: OperationIndex, opsA: Operation[], opsB: Operation[]) => Operation[];
+declare function checkCleanedOperationsIntegrity(sortedOperations: OperationIndex[]): IntegrityIssue[];
+declare function garbageCollect<TOpIndex extends OperationIndex>(sortedOperations: TOpIndex[]): TOpIndex[];
+declare function addUndo(sortedOperations: Operation[]): Operation[];
+declare function sortOperations<TOpIndex extends OperationIndex>(operations: TOpIndex[]): TOpIndex[];
+declare function reshuffleByTimestamp<TOp extends OperationIndex>(startIndex: OperationIndex, opsA: TOp[], opsB: TOp[]): TOp[];
+declare function reshuffleByTimestampAndIndex<TOp extends OperationIndex>(startIndex: OperationIndex, opsA: TOp[], opsB: TOp[]): TOp[];
+declare function operationsAreEqual<TOp extends {
+  index: number;
+  skip: number;
+  type?: string;
+  scope?: string;
+  input?: unknown;
+}>(op1: TOp, op2: TOp): boolean;
+declare function attachBranch(trunk: Operation[], newBranch: Operation[]): [Operation[], Operation[]];
+declare function precedes(op1: OperationIndex, op2: OperationIndex): boolean;
+declare function split(sortedTargetOperations: Operation[], sortedMergeOperations: Operation[]): [Operation[], Operation[], Operation[]];
+declare function merge(sortedTargetOperations: Operation[], sortedMergeOperations: Operation[], reshuffle: Reshuffle): Operation[];
+declare function nextSkipNumber(sortedOperations: OperationIndex[]): number;
+declare function checkOperationsIntegrity(operations: Operation[]): IntegrityIssue[];
+declare function groupOperationsByScope(operations: Operation[]): Partial<Record<string, Operation[]>>;
+type PrepareOperationsResult = {
+  validOperations: Operation[];
+  invalidOperations: Operation[];
+  duplicatedOperations: Operation[];
+  integrityIssues: IntegrityIssue[];
+};
+declare function prepareOperations(operationsHistory: Operation[], newOperations: Operation[]): PrepareOperationsResult;
+declare function removeExistingOperations(newOperations: Operation[], operationsHistory: Operation[]): Operation[];
+/**
+ * Skips header operations and returns the remaining operations.
+ *
+ * @param operations - The array of operations.
+ * @param skipHeaderOperation - The skip header operation index.
+ * @returns The remaining operations after skipping header operations.
+ */
+declare function skipHeaderOperations(operations: Operation[], skipHeaderOperation: SkipHeaderOperationIndex): Operation[];
+declare function garbageCollectDocumentOperations(documentOperations: DocumentOperations): DocumentOperations;
+/**
+ * Filters out duplicated operations from the target operations array based on their IDs.
+ * If an operation has an ID, it is considered duplicated if there is another operation in the source operations array with the same ID.
+ * If an operation does not have an ID, it is considered unique and will not be filtered out.
+ * @param targetOperations - The array of target operations to filter.
+ * @param sourceOperations - The array of source operations to compare against.
+ * @returns An array of operations with duplicates filtered out.
+ */
+declare function filterDuplicatedOperations<T extends {
+  id?: string | number;
+}>(targetOperations: T[], sourceOperations: T[]): T[];
+declare function filterDocumentOperationsResultingState(documentOperations?: DocumentOperations): {
+  [x: string]: Operation[] | {
+    id: string;
+    index: number;
+    skip: number;
+    timestampUtcMs: string;
+    hash: string;
+    error?: string;
+    action: Action;
+  }[];
+};
+/**
+ * Calculates the difference between two arrays of operations.
+ * Returns an array of operations that are present in `clearedOperationsA` but not in `clearedOperationsB`.
+ *
+ * @template TOp - The type of the operations.
+ * @param {TOp[]} clearedOperationsA - The first array of operations.
+ * @param {TOp[]} clearedOperationsB - The second array of operations.
+ * @returns {TOp[]} - The difference between the two arrays of operations.
+ */
+declare function diffOperations<TOp extends OperationIndex>(clearedOperationsA: TOp[], clearedOperationsB: TOp[]): TOp[];
+declare function getDocumentLastModified(document: PHDocument): string;
+/**
+ * Updates the document header with the latest revision number and
+ * date of last modification.
+ *
+ * @param document The current state of the document.
+ * @param scope The scope of the operation.
+ * @param lastModifiedTimestamp Optional timestamp to use directly, avoiding a scan of all operations.
+ * @returns The updated document state.
+ */
+declare function updateHeaderRevision(document: PHDocument, scope: string, lastModifiedTimestamp?: string): PHDocument;
+//#endregion
+//#region document-model/actions.d.ts
+/**
+ * Cancels the last `count` operations.
+ *
+ * @param count - Number of operations to cancel
+ * @category Actions
+ */
+declare const undo: (count?: number, scope?: string) => UndoAction;
+/**
+ * Cancels the last `count` {@link undo | UNDO} operations.
+ *
+ * @param count - Number of UNDO operations to cancel
+ * @category Actions
+ */
+declare const redo: (count?: number, scope?: string) => RedoAction;
+/**
+ * Joins multiple operations into a single {@link loadState | LOAD_STATE} operation.
+ *
+ * @remarks
+ * Useful to keep operations history smaller. Operations to prune are selected by index,
+ * similar to the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice | slice} method in Arrays.
+ *
+ * @param start - Index of the first operation to prune
+ * @param end - Index of the last operation to prune
+ * @category Actions
+ */
+declare const prune: (start?: number, end?: number, scope?: string) => SchemaPruneAction;
+/**
+ * Replaces the state of the document.
+ *
+ * @remarks
+ * This action shouldn't be used directly. It is dispatched by the {@link prune} action.
+ *
+ * @param state - State to be set in the document.
+ * @param operations - Number of operations that were removed from the previous state.
+ * @category Actions
+ */
+declare const loadState: <TState extends PHBaseState = PHBaseState>(state: TState & {
+  name: string;
+}, operations: number) => LoadStateAction;
+declare const noop: (scope?: string) => NOOPAction;
+/**
+ * Helper function to be used by action creators.
+ *
+ * @remarks
+ * Creates an action with the given type and input properties. The input
+ * properties default to an empty object.
+ *
+ * @typeParam A - Type of the action to be returned.
+ *
+ * @param type - The type of the action.
+ * @param input - The input properties of the action.
+ * @param attachments - The attachments included in the action.
+ * @param validator - The validator to use for the input properties.
+ * @param scope - The scope of the action, can either be 'global' or 'local'.
+ * @param skip - The number of operations to skip before this new action is applied.
+ *
+ * @throws Error if the type is empty or not a string.
+ *
+ * @returns The new action.
+ */
+declare function createAction<TAction extends Action>(type: TAction["type"], input?: TAction["input"], attachments?: TAction["attachments"], validator?: () => {
+  parse(v: unknown): TAction["input"];
+}, scope?: Action["scope"]): TAction;
+/**
+ * This function should be used instead of { ...action } to ensure
+ * that extra properties are not included in the action.
+ */
+declare const actionFromAction: (action: Action) => Action;
+declare const operationFromAction: (action: Action, index: number, skip: number, context: OperationContext) => Operation;
+declare const operationFromOperation: (operation: Operation, index: number, skip: number, context: OperationContext) => Operation;
+declare const operationWithContext: (operation: Operation, context: ActionContext) => Operation;
+declare const actionContext: () => ActionContext;
+declare const actionSigner: (user: UserActionSigner, app: AppActionSigner, signatures?: Signature[]) => ActionSigner;
+declare function buildOperationSignature(context: ActionSignatureContext, signMethod: ActionSigningHandler): Promise<Signature>;
+declare function buildSignedAction<TState extends PHBaseState = PHBaseState>(action: Action, reducer: Reducer<TState>, document: PHDocument<TState>, signer: ActionSigner, signHandler: ActionSigningHandler): Promise<Operation>;
+declare function verifyOperationSignature(signature: Signature, signer: Omit<ActionSigner, "signatures">, verifyHandler: ActionVerificationHandler): Promise<boolean>;
+/**
+ * Changes the name of the document.
+ *
+ * @param name - The name to be set in the document.
+ * @category Actions
+ */
+declare const setName: (name: string | {
+  name: string;
+}) => SetNameAction;
+/**
+ * Changes the preferred editor recorded in the document header meta.
+ *
+ * Passing `null` clears the preferred editor.
+ *
+ * @category Actions
+ */
+declare const setPreferredEditor: (input: string | null | {
+  preferredEditor: string | null;
+}) => SetPreferredEditorAction;
+declare const setModelName: (input: SetModelNameInput) => SetModelNameAction;
+declare const setModelId: (input: SetModelIdInput) => SetModelIdAction;
+declare const setModelExtension: (input: SetModelExtensionInput) => SetModelExtensionAction;
+declare const setModelDescription: (input: SetModelDescriptionInput) => SetModelDescriptionAction;
+declare const setAuthorName: (input: SetAuthorNameInput) => SetAuthorNameAction;
+declare const setAuthorWebsite: (input: SetAuthorWebsiteInput) => SetAuthorWebsiteAction;
+declare const addModule: (input: AddModuleInput) => AddModuleAction;
+declare const setModuleName: (input: SetModuleNameInput) => SetModuleNameAction;
+declare const setModuleDescription: (input: SetModuleDescriptionInput) => SetModuleDescriptionAction;
+declare const deleteModule: (input: DeleteModuleInput) => DeleteModuleAction;
+declare const reorderModules: (input: ReorderModulesInput) => ReorderModulesAction;
+declare const addOperation: (input: AddOperationInput) => AddOperationAction;
+declare const setOperationName: (input: SetOperationNameInput) => SetOperationNameAction;
+declare const setOperationScope: (input: SetOperationScopeInput) => SetOperationScopeAction;
+declare const setOperationSchema: (input: SetOperationSchemaInput) => SetOperationSchemaAction;
+declare const setOperationDescription: (input: SetOperationDescriptionInput) => SetOperationDescriptionAction;
+declare const setOperationTemplate: (input: SetOperationTemplateInput) => SetOperationTemplateAction;
+declare const setOperationReducer: (input: SetOperationReducerInput) => SetOperationReducerAction;
+declare const moveOperation: (input: MoveOperationInput) => MoveOperationAction;
+declare const deleteOperation: (input: DeleteOperationInput) => DeleteOperationAction;
+declare const reorderModuleOperations: (input: ReorderModuleOperationsInput) => ReorderModuleOperationsAction;
+declare const addOperationError: (input: AddOperationErrorInput) => AddOperationErrorAction;
+declare const setOperationErrorCode: (input: SetOperationErrorCodeInput) => SetOperationErrorCodeAction;
+declare const setOperationErrorName: (input: SetOperationErrorNameInput) => SetOperationErrorNameAction;
+declare const setOperationErrorDescription: (input: SetOperationErrorDescriptionInput) => SetOperationErrorDescriptionAction;
+declare const setOperationErrorTemplate: (input: SetOperationErrorTemplateInput) => SetOperationErrorTemplateAction;
+declare const deleteOperationError: (input: DeleteOperationErrorInput) => DeleteOperationErrorAction;
+declare const reorderOperationErrors: (input: ReorderOperationErrorsInput) => ReorderOperationErrorsAction;
+declare const addOperationExample: (input: AddOperationExampleInput) => AddOperationExampleAction;
+declare const updateOperationExample: (input: UpdateOperationExampleInput) => UpdateOperationExampleAction;
+declare const deleteOperationExample: (input: DeleteOperationExampleInput) => DeleteOperationExampleAction;
+declare const reorderOperationExamples: (input: ReorderOperationExamplesInput) => ReorderOperationExamplesAction;
+declare const operationExampleCreators: {
+  addOperationExample: (input: AddOperationExampleInput) => AddOperationExampleAction;
+  updateOperationExample: (input: UpdateOperationExampleInput) => UpdateOperationExampleAction;
+  deleteOperationExample: (input: DeleteOperationExampleInput) => DeleteOperationExampleAction;
+  reorderOperationExamples: (input: ReorderOperationExamplesInput) => ReorderOperationExamplesAction;
+};
+declare const setStateSchema: (input: SetStateSchemaInput) => SetStateSchemaAction;
+declare const setInitialState: (input: SetInitialStateInput) => SetInitialStateAction;
+declare const addStateExample: (input: AddStateExampleInput) => AddStateExampleAction;
+declare const updateStateExample: (input: UpdateStateExampleInput) => UpdateStateExampleAction;
+declare const deleteStateExample: (input: DeleteStateExampleInput) => DeleteStateExampleAction;
+declare const reorderStateExamples: (input: ReorderStateExamplesInput) => ReorderStateExamplesAction;
+declare const addChangeLogItem: (input: AddChangeLogItemInput) => AddChangeLogItemAction;
+declare const updateChangeLogItem: (input: UpdateChangeLogItemInput) => UpdateChangeLogItemAction;
+declare const deleteChangeLogItem: (input: DeleteChangeLogItemInput) => DeleteChangeLogItemAction;
+declare const reorderChangeLogItems: (input: ReorderChangeLogItemsInput) => ReorderChangeLogItemsAction;
+declare const releaseNewVersion: () => ReleaseNewVersionAction;
+declare const baseActions: {
+  setName: (name: string | {
+    name: string;
+  }) => SetNameAction;
+  setPreferredEditor: (input: string | null | {
+    preferredEditor: string | null;
+  }) => SetPreferredEditorAction;
+  undo: (count?: number, scope?: string) => UndoAction;
+  redo: (count?: number, scope?: string) => RedoAction;
+  prune: (start?: number, end?: number, scope?: string) => SchemaPruneAction;
+  loadState: <TState extends PHBaseState = PHBaseState>(state: TState & {
+    name: string;
+  }, operations: number) => LoadStateAction;
+  noop: (scope?: string) => NOOPAction;
+};
+declare const documentModelActions: {
+  setModelName: (input: SetModelNameInput) => SetModelNameAction;
+  setModelId: (input: SetModelIdInput) => SetModelIdAction;
+  setModelExtension: (input: SetModelExtensionInput) => SetModelExtensionAction;
+  setModelDescription: (input: SetModelDescriptionInput) => SetModelDescriptionAction;
+  setAuthorName: (input: SetAuthorNameInput) => SetAuthorNameAction;
+  setAuthorWebsite: (input: SetAuthorWebsiteInput) => SetAuthorWebsiteAction;
+  addModule: (input: AddModuleInput) => AddModuleAction;
+  setModuleName: (input: SetModuleNameInput) => SetModuleNameAction;
+  setModuleDescription: (input: SetModuleDescriptionInput) => SetModuleDescriptionAction;
+  deleteModule: (input: DeleteModuleInput) => DeleteModuleAction;
+  reorderModules: (input: ReorderModulesInput) => ReorderModulesAction;
+  addOperation: (input: AddOperationInput) => AddOperationAction;
+  setOperationName: (input: SetOperationNameInput) => SetOperationNameAction;
+  setOperationScope: (input: SetOperationScopeInput) => SetOperationScopeAction;
+  setOperationSchema: (input: SetOperationSchemaInput) => SetOperationSchemaAction;
+  setOperationDescription: (input: SetOperationDescriptionInput) => SetOperationDescriptionAction;
+  setOperationTemplate: (input: SetOperationTemplateInput) => SetOperationTemplateAction;
+  setOperationReducer: (input: SetOperationReducerInput) => SetOperationReducerAction;
+  moveOperation: (input: MoveOperationInput) => MoveOperationAction;
+  deleteOperation: (input: DeleteOperationInput) => DeleteOperationAction;
+  reorderModuleOperations: (input: ReorderModuleOperationsInput) => ReorderModuleOperationsAction;
+  addOperationError: (input: AddOperationErrorInput) => AddOperationErrorAction;
+  setOperationErrorCode: (input: SetOperationErrorCodeInput) => SetOperationErrorCodeAction;
+  setOperationErrorName: (input: SetOperationErrorNameInput) => SetOperationErrorNameAction;
+  setOperationErrorDescription: (input: SetOperationErrorDescriptionInput) => SetOperationErrorDescriptionAction;
+  setOperationErrorTemplate: (input: SetOperationErrorTemplateInput) => SetOperationErrorTemplateAction;
+  deleteOperationError: (input: DeleteOperationErrorInput) => DeleteOperationErrorAction;
+  reorderOperationErrors: (input: ReorderOperationErrorsInput) => ReorderOperationErrorsAction;
+  addOperationExample: (input: AddOperationExampleInput) => AddOperationExampleAction;
+  updateOperationExample: (input: UpdateOperationExampleInput) => UpdateOperationExampleAction;
+  deleteOperationExample: (input: DeleteOperationExampleInput) => DeleteOperationExampleAction;
+  reorderOperationExamples: (input: ReorderOperationExamplesInput) => ReorderOperationExamplesAction;
+  setStateSchema: (input: SetStateSchemaInput) => SetStateSchemaAction;
+  setInitialState: (input: SetInitialStateInput) => SetInitialStateAction;
+  addStateExample: (input: AddStateExampleInput) => AddStateExampleAction;
+  updateStateExample: (input: UpdateStateExampleInput) => UpdateStateExampleAction;
+  deleteStateExample: (input: DeleteStateExampleInput) => DeleteStateExampleAction;
+  reorderStateExamples: (input: ReorderStateExamplesInput) => ReorderStateExamplesAction;
+  addChangeLogItem: (input: AddChangeLogItemInput) => AddChangeLogItemAction;
+  updateChangeLogItem: (input: UpdateChangeLogItemInput) => UpdateChangeLogItemAction;
+  deleteChangeLogItem: (input: DeleteChangeLogItemInput) => DeleteChangeLogItemAction;
+  reorderChangeLogItems: (input: ReorderChangeLogItemsInput) => ReorderChangeLogItemsAction;
+  releaseNewVersion: () => ReleaseNewVersionAction;
+};
+declare const actions: {
+  setModelName: (input: SetModelNameInput) => SetModelNameAction;
+  setModelId: (input: SetModelIdInput) => SetModelIdAction;
+  setModelExtension: (input: SetModelExtensionInput) => SetModelExtensionAction;
+  setModelDescription: (input: SetModelDescriptionInput) => SetModelDescriptionAction;
+  setAuthorName: (input: SetAuthorNameInput) => SetAuthorNameAction;
+  setAuthorWebsite: (input: SetAuthorWebsiteInput) => SetAuthorWebsiteAction;
+  addModule: (input: AddModuleInput) => AddModuleAction;
+  setModuleName: (input: SetModuleNameInput) => SetModuleNameAction;
+  setModuleDescription: (input: SetModuleDescriptionInput) => SetModuleDescriptionAction;
+  deleteModule: (input: DeleteModuleInput) => DeleteModuleAction;
+  reorderModules: (input: ReorderModulesInput) => ReorderModulesAction;
+  addOperation: (input: AddOperationInput) => AddOperationAction;
+  setOperationName: (input: SetOperationNameInput) => SetOperationNameAction;
+  setOperationScope: (input: SetOperationScopeInput) => SetOperationScopeAction;
+  setOperationSchema: (input: SetOperationSchemaInput) => SetOperationSchemaAction;
+  setOperationDescription: (input: SetOperationDescriptionInput) => SetOperationDescriptionAction;
+  setOperationTemplate: (input: SetOperationTemplateInput) => SetOperationTemplateAction;
+  setOperationReducer: (input: SetOperationReducerInput) => SetOperationReducerAction;
+  moveOperation: (input: MoveOperationInput) => MoveOperationAction;
+  deleteOperation: (input: DeleteOperationInput) => DeleteOperationAction;
+  reorderModuleOperations: (input: ReorderModuleOperationsInput) => ReorderModuleOperationsAction;
+  addOperationError: (input: AddOperationErrorInput) => AddOperationErrorAction;
+  setOperationErrorCode: (input: SetOperationErrorCodeInput) => SetOperationErrorCodeAction;
+  setOperationErrorName: (input: SetOperationErrorNameInput) => SetOperationErrorNameAction;
+  setOperationErrorDescription: (input: SetOperationErrorDescriptionInput) => SetOperationErrorDescriptionAction;
+  setOperationErrorTemplate: (input: SetOperationErrorTemplateInput) => SetOperationErrorTemplateAction;
+  deleteOperationError: (input: DeleteOperationErrorInput) => DeleteOperationErrorAction;
+  reorderOperationErrors: (input: ReorderOperationErrorsInput) => ReorderOperationErrorsAction;
+  addOperationExample: (input: AddOperationExampleInput) => AddOperationExampleAction;
+  updateOperationExample: (input: UpdateOperationExampleInput) => UpdateOperationExampleAction;
+  deleteOperationExample: (input: DeleteOperationExampleInput) => DeleteOperationExampleAction;
+  reorderOperationExamples: (input: ReorderOperationExamplesInput) => ReorderOperationExamplesAction;
+  setStateSchema: (input: SetStateSchemaInput) => SetStateSchemaAction;
+  setInitialState: (input: SetInitialStateInput) => SetInitialStateAction;
+  addStateExample: (input: AddStateExampleInput) => AddStateExampleAction;
+  updateStateExample: (input: UpdateStateExampleInput) => UpdateStateExampleAction;
+  deleteStateExample: (input: DeleteStateExampleInput) => DeleteStateExampleAction;
+  reorderStateExamples: (input: ReorderStateExamplesInput) => ReorderStateExamplesAction;
+  addChangeLogItem: (input: AddChangeLogItemInput) => AddChangeLogItemAction;
+  updateChangeLogItem: (input: UpdateChangeLogItemInput) => UpdateChangeLogItemAction;
+  deleteChangeLogItem: (input: DeleteChangeLogItemInput) => DeleteChangeLogItemAction;
+  reorderChangeLogItems: (input: ReorderChangeLogItemsInput) => ReorderChangeLogItemsAction;
+  releaseNewVersion: () => ReleaseNewVersionAction;
+  setName: (name: string | {
+    name: string;
+  }) => SetNameAction;
+  setPreferredEditor: (input: string | null | {
+    preferredEditor: string | null;
+  }) => SetPreferredEditorAction;
+  undo: (count?: number, scope?: string) => UndoAction;
+  redo: (count?: number, scope?: string) => RedoAction;
+  prune: (start?: number, end?: number, scope?: string) => SchemaPruneAction;
+  loadState: <TState extends PHBaseState = PHBaseState>(state: TState & {
+    name: string;
+  }, operations: number) => LoadStateAction;
+  noop: (scope?: string) => NOOPAction;
+};
+/**
+ * The context of an action.
+ */
+type ActionContext = {
+  /** The index of the previous operation, showing intended ordering. */prevOpIndex?: number; /** The hash of the previous operation, showing intended state. */
+  prevOpHash?: string; /** A nonce, to cover specific signing attacks and to prevent replay attacks from no-ops. */
+  nonce?: string; /** The signer of the action. */
+  signer?: ActionSigner;
+};
+/**
+ * Defines the basic structure of an action.
+ */
+type Action = {
+  /** The id of the action. This is distinct from the operation id. */id: string; /** The name of the action. */
+  type: string; /** The timestamp of the action. */
+  timestampUtcMs: string; /** The payload of the action. */
+  input: unknown; /** The scope of the action */
+  scope: string;
+  /**
+   * The attachments included in the action.
+   *
+   * This will be refactored in a future release.
+   */
+  attachments?: AttachmentInput[]; /** The context of the action. */
+  context?: ActionContext;
+};
+/**
+ * The attributes stored for a file. Namely, attachments of a document.
+ */
+type Attachment = {
+  /** The binary data of the attachment in Base64 */data: string; /** The MIME type of the attachment */
+  mimeType: string;
+  extension?: string | null;
+  fileName?: string | null;
+};
+type AttachmentInput = Attachment & {
+  hash: string;
+};
+type ActionWithAttachment = Action & {
+  attachments: AttachmentInput[];
+};
+/**
+ * String type representing an attachment in a Document.
+ *
+ * @remarks
+ * Attachment string is formatted as `attachment://<filename>`.
+ */
+type AttachmentRef = string;
+//#endregion
+//#region processors/types.d.ts
+type ProcessorDispatchResult = {
+  id: string;
+  status: string;
+};
+interface IProcessorDispatch {
+  execute(docId: string, branch: string, actions: Action[], signal?: AbortSignal, meta?: Record<string, unknown>): Promise<ProcessorDispatchResult>;
+}
+interface IProcessorHostModule {
+  analyticsStore: IAnalyticsStore;
+  relationalDb: IRelationalDb;
+  processorApp: ProcessorApp;
+  dispatch: IProcessorDispatch;
+  getReadModel<T>(name: string): T;
+  config?: Map<string, unknown>;
+}
+/**
+ * Filter for matching operations to processors.
+ * All fields are optional arrays - when provided, operations must match at least one value in each specified field.
+ * When a field is undefined or empty, it matches all values for that field.
+ */
+type ProcessorFilter = {
+  documentType?: string[];
+  scope?: string[];
+  branch?: string[];
+  documentId?: string[];
+};
+/**
+ * Describes an object that can process operations.
+ */
+interface IProcessor {
+  /**
+   * Processes a list of operations with context.
+   * Called when operations match this processor's filter.
+   */
+  onOperations(operations: OperationWithContext[]): Promise<void>;
+  /**
+   * Called when the processor is disconnected.
+   * Used to clean up any resources allocated during processor creation.
+   */
+  onDisconnect(): Promise<void>;
+}
+/**
+ * Relates a processor to its filter configuration.
+ */
+type ProcessorRecord = {
+  processor: IProcessor;
+  filter: ProcessorFilter;
+  startFrom?: "beginning" | "current";
+};
+/**
+ * A factory function that creates processor records for a given drive.
+ * Called once per drive when the drive is first detected or when the factory is registered.
+ */
+type ProcessorFactory = (driveHeader: PHDocumentHeader, processorApp?: ProcessorApp) => Promise<ProcessorRecord[]> | ProcessorRecord[];
+/** Takes a processor host module and builds processor factories using its context */
+type ProcessorFactoryBuilder = (module: IProcessorHostModule) => Promise<ProcessorFactory> | ProcessorFactory;
+type ProcessorStatus = "active" | "errored";
+type TrackedProcessor = {
+  processorId: string;
+  factoryId: string;
+  driveId: string;
+  processorIndex: number;
+  record: ProcessorRecord;
+  lastOrdinal: number;
+  status: ProcessorStatus;
+  lastError: string | undefined;
+  lastErrorTimestamp: Date | undefined;
+  retry: () => Promise<void>;
+};
+/**
+ * Manages processor creation and destruction based on drive operations.
+ */
+interface IProcessorManager {
+  /**
+   * Registers a processor factory.
+   * Immediately creates processors for all existing drives.
+   */
+  registerFactory(identifier: string, factory: ProcessorFactory): Promise<void>;
+  /**
+   * Unregisters a processor factory and disconnects all processors it created.
+   */
+  unregisterFactory(identifier: string): Promise<void>;
+  /**
+   * Gets a tracked processor by its ID.
+   */
+  get(processorId: string): TrackedProcessor | undefined;
+  /**
+   * Gets all tracked processors.
+   */
+  getAll(): TrackedProcessor[];
+}
+type ProcessorApp = (typeof PROCESSOR_APPS)[number];
+type ProcessorApps = readonly ProcessorApp[];
+//#endregion
+//#region processors/relational/types.d.ts
+type IRelationalQueryMethods = "selectFrom" | "selectNoFrom" | "with" | "withRecursive";
+type IRelationalQueryBuilder<Schema = unknown> = Pick<QueryCreator<Schema>, IRelationalQueryMethods> & {
+  withSchema: (schema: string) => IRelationalQueryBuilder<Schema>;
+};
+type HashAlgorithms = "fnv1a";
+type IBaseRelationalDb<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 IRelationalDb<Schema = unknown> = IBaseRelationalDb<Schema> & {
+  createNamespace<NamespaceSchema>(namespace: string): Promise<IRelationalDb<ExtractProcessorSchemaOrSelf<NamespaceSchema>>>;
+  queryNamespace<NamespaceSchema>(namespace: string): IRelationalQueryBuilder<NamespaceSchema>;
+};
+type ExtractProcessorSchemaOrSelf<TProcessor> = TProcessor extends RelationalDbProcessor<infer TSchema> ? TSchema : TProcessor;
+type RelationalDbProcessorClass<TSchema> = typeof RelationalDbProcessor<TSchema>;
+interface IRelationalDbProcessor<TDatabaseSchema = unknown> extends IProcessor {
+  namespace: string;
+  query: IRelationalQueryBuilder<TDatabaseSchema>;
+  filter: ProcessorFilter;
+  initAndUpgrade(): Promise<void>;
+}
+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 RelationalDbProcessor<TDatabaseSchema = unknown> implements IRelationalDbProcessor<TDatabaseSchema> {
+  protected _namespace: string;
+  protected _filter: ProcessorFilter;
+  protected relationalDb: IRelationalDb<TDatabaseSchema>;
+  constructor(_namespace: string, _filter: ProcessorFilter, relationalDb: IRelationalDb<TDatabaseSchema>);
+  static [IS_RELATIONAL_DB_PROCESSOR]: boolean;
+  /**
+   * 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: RelationalDbProcessorClass<Schema>, driveId: string, db: IRelationalDb<any>): IRelationalQueryBuilder<Schema>;
+  /**
+   * Processes a list of operations with context.
+   * Called when operations match this processor's filter.
+   */
+  abstract onOperations(operations: OperationWithContext[]): Promise<void>;
+  /**
+   * Returns the filter for the processor.
+   * This method can be overridden by derived classes to provide a custom filter.
+   */
+  get filter(): ProcessorFilter;
+  /**
+   * Returns the namespace used by the processor.
+   */
+  get namespace(): string;
+  get query(): IRelationalQueryBuilder<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>;
+  /**
+   * Called when the processor is disconnected.
+   * This method is meant to be overridden by subclasses to clean up resources.
+   */
+  abstract onDisconnect(): Promise<void>;
+}
+//#endregion
+//#region processors/relational/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 hashNamespace(str: string, length?: number): 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 createRelationalDb<Schema>(baseDb: IBaseRelationalDb<Schema>, baseOptions?: NamespaceOptions): IRelationalDb<Schema>;
+type NamespaceOptions = {
+  hashNamespace?: boolean;
+};
+declare function createNamespacedDb<Schema>(db: IBaseRelationalDb<any>, namespace: string, options?: NamespaceOptions): Promise<IRelationalDb<Schema>>;
+declare function createNamespacedQueryBuilder<Schema>(db: IBaseRelationalDb<any>, namespace: string, options?: NamespaceOptions): IRelationalQueryBuilder<Schema>;
+/**
+ * Returns a query builder for a RelationalDb instance.
+ * @param query The RelationalDb instance to convert.
+ * @returns The IRelationalQueryBuilder instance.
  */
 declare function relationalDbToQueryBuilder<TSchema>(query: IBaseRelationalDb<TSchema>): IRelationalQueryBuilder<TSchema>;
 //#endregion
@@ -19888,1181 +20615,454 @@ type LoadStateActionInput = {
   state: LoadStateActionStateInput;
 };
 type LoadStateActionStateInput = {
-  data?: InputMaybe<Scalars["Unknown"]["input"]>;
-  name: Scalars["String"]["input"];
-};
-type MutationLoadStateArgs = {
-  input: SchemaLoadStateAction;
-};
-type MutationPruneArgs = {
-  input: SchemaPruneAction;
-};
-type MutationRedoArgs = {
-  input: SchemaRedoAction;
-};
-type MutationSetNameArgs = {
-  input: SchemaSetNameAction;
-};
-type MutationUndoArgs = {
-  input: SchemaUndoAction;
-};
-type Prune = "PRUNE";
-type SchemaPruneAction = {
-  id: Scalars["String"]["output"];
-  timestampUtcMs: Scalars["DateTime"]["output"];
-  input: PruneActionInput;
-  type: Prune;
-  scope: string;
-};
-type PruneActionInput = {
-  end?: InputMaybe<Scalars["Int"]["input"]>;
-  start?: InputMaybe<Scalars["Int"]["input"]>;
-};
-type Query = {
-  __typename?: "Query";
-  document: Maybe<IDocument>;
-};
-type Redo = "REDO";
-type RedoActionInput = {
-  count: Scalars["Int"]["input"];
-};
-type SchemaRedoAction = {
-  id: Scalars["String"]["output"];
-  timestampUtcMs: Scalars["DateTime"]["output"];
-  input: RedoActionInput;
-  type: Redo;
-  scope: string;
-};
-type Set_Name = "SET_NAME";
-type SetNameActionInput = {
-  name: Scalars["String"]["input"];
-};
-type SchemaSetNameAction = {
-  id: Scalars["String"]["output"];
-  timestampUtcMs: Scalars["DateTime"]["output"];
-  input: SetNameActionInput;
-  type: Set_Name;
-  scope: "global";
-};
-type SetNameOperation = IOperation & {
-  __typename?: "SetNameOperation";
-  hash: Scalars["String"]["output"];
-  index: Scalars["Int"]["output"];
-  input: Scalars["String"]["output"];
-  timestamp: Scalars["DateTime"]["output"];
-  type: Scalars["String"]["output"];
-};
-type Set_PreferredEditor = "SET_PREFERRED_EDITOR";
-type SetPreferredEditorActionInput = {
-  preferredEditor: Scalars["String"]["input"] | null;
-};
-type SchemaSetPreferredEditorAction = {
-  id: Scalars["String"]["output"];
-  timestampUtcMs: Scalars["DateTime"]["output"];
-  input: SetPreferredEditorActionInput;
-  type: Set_PreferredEditor;
-  scope: "header";
-};
-type SetPreferredEditorOperation = IOperation & {
-  __typename?: "SetPreferredEditorOperation";
-  hash: Scalars["String"]["output"];
-  index: Scalars["Int"]["output"];
-  input: SetPreferredEditorActionInput;
-  timestamp: Scalars["DateTime"]["output"];
-  type: Scalars["String"]["output"];
-};
-type Undo = "UNDO";
-type UndoActionInput = {
-  count: Scalars["Int"]["input"];
-};
-type SchemaUndoAction = {
-  id: Scalars["String"]["output"];
-  timestampUtcMs: Scalars["DateTime"]["output"];
-  input: UndoActionInput;
-  type: Undo;
-  scope: string;
-};
-type SchemaNOOPAction = {
-  id: Scalars["String"]["output"];
-  input: Scalars["Unknown"]["input"];
-  scope: string;
-  timestampUtcMs: Scalars["DateTime"]["output"];
-  type: "NOOP";
-};
-type LoadStateAction = Action & {
-  type: "LOAD_STATE";
-  input: LoadStateActionInput;
-};
-type PruneAction = Action & {
-  type: "PRUNE";
-  input: PruneActionInput;
-};
-type RedoAction = Action & {
-  type: "REDO";
-  input: SchemaRedoAction["input"];
-};
-type SetNameAction = Action & {
-  type: "SET_NAME";
-  input: SchemaSetNameAction["input"];
-};
-type SetPreferredEditorAction = Action & {
-  type: "SET_PREFERRED_EDITOR";
-  input: SchemaSetPreferredEditorAction["input"];
-};
-type UndoAction = Action & {
-  type: "UNDO";
-  input: SchemaUndoAction["input"];
-};
-type NOOPAction = Action & {
-  type: "NOOP";
-  input: SchemaNOOPAction["input"];
-};
-type CreateDocumentActionInput = {
-  model: string;
-  version: 0;
-  documentId: string;
-  signing?: {
-    signature: string;
-    publicKey: JsonWebKey;
-    nonce: string;
-    createdAtUtcIso: string;
-    documentType: string;
-  };
-  slug?: string;
-  name?: string;
-  branch?: string;
-  meta?: Record<string, unknown>;
-  protocolVersions?: {
-    [key: string]: number;
-  };
-};
-type UpgradeDocumentActionInput = {
-  model: string;
-  fromVersion: number;
-  toVersion: number;
-  documentId: string;
-  initialState?: object;
-};
-type DeleteDocumentActionInput = {
-  documentId: string;
-  propagate?: "none" | "cascade";
-};
-type AddRelationshipActionInput = {
-  sourceId: string;
-  targetId: string;
-  relationshipType: string;
-  metadata?: Record<string, unknown>;
-};
-type RemoveRelationshipActionInput = {
-  sourceId: string;
-  targetId: string;
-  relationshipType: string;
-};
-type UpdateRelationshipActionInput = {
-  sourceId: string;
-  targetId: string;
-  relationshipType: string;
-  metadata: Record<string, unknown> | null;
-};
-type CreateDocumentAction = Action & {
-  type: "CREATE_DOCUMENT";
-  input: CreateDocumentActionInput;
-};
-type UpgradeDocumentAction = Action & {
-  type: "UPGRADE_DOCUMENT";
-  input: UpgradeDocumentActionInput;
-};
-type DeleteDocumentAction = Action & {
-  type: "DELETE_DOCUMENT";
-  input: DeleteDocumentActionInput;
-};
-type AddRelationshipAction = Action & {
-  type: "ADD_RELATIONSHIP";
-  input: AddRelationshipActionInput;
-};
-type RemoveRelationshipAction = Action & {
-  type: "REMOVE_RELATIONSHIP";
-  input: RemoveRelationshipActionInput;
-};
-type UpdateRelationshipAction = Action & {
-  type: "UPDATE_RELATIONSHIP";
-  input: UpdateRelationshipActionInput;
-};
-type DocumentAction = LoadStateAction | PruneAction | RedoAction | SetNameAction | SetPreferredEditorAction | UndoAction | NOOPAction;
-interface ISignal<TType extends string, TInput> {
-  type: TType;
-  input: TInput;
-}
-type ISignalResult<TTYpe, TInput, TResult> = {
-  signal: {
-    type: TTYpe;
-    input: TInput;
-  };
-  result: TResult;
+  data?: InputMaybe<Scalars["Unknown"]["input"]>;
+  name: Scalars["String"]["input"];
 };
-type CreateChildDocumentInput = {
-  id: string;
-  documentType: string;
+type MutationLoadStateArgs = {
+  input: SchemaLoadStateAction;
 };
-type CreateChildDocumentSignal = ISignal<"CREATE_CHILD_DOCUMENT", CreateChildDocumentInput>;
-type DeleteChildDocumentInput = {
-  id: string;
+type MutationPruneArgs = {
+  input: SchemaPruneAction;
 };
-type DeleteChildDocumentSignal = ISignal<"DELETE_CHILD_DOCUMENT", DeleteChildDocumentInput>;
-type CopyChildDocumentInput = {
-  id: string;
-  newId: string;
+type MutationRedoArgs = {
+  input: SchemaRedoAction;
 };
-type CopyChildDocumentSignal = ISignal<"COPY_CHILD_DOCUMENT", CopyChildDocumentInput>;
-type Signal = CreateChildDocumentSignal | CopyChildDocumentSignal | DeleteChildDocumentSignal;
-type SignalDispatch = (signal: Signal) => void;
-type SignalResult = ISignalResult<CreateChildDocumentSignal["type"], CreateChildDocumentSignal["input"], PHDocument> | ISignalResult<CopyChildDocumentSignal["type"], CopyChildDocumentSignal["input"], boolean> | ISignalResult<DeleteChildDocumentSignal["type"], DeleteChildDocumentSignal["input"], PHDocument>;
-type SignalResults = {
-  CREATE_CHILD_DOCUMENT: PHDocument;
-  COPY_CHILD_DOCUMENT: PHDocument;
-  DELETE_CHILD_DOCUMENT: boolean;
+type MutationSetNameArgs = {
+  input: SchemaSetNameAction;
 };
-type SignalType<T extends Signal> = T["type"];
-type FileInput = string | number[] | Uint8Array | ArrayBuffer | Blob;
-type ReducerOptions = {
-  /** The number of operations to skip before this new action is applied. This overrides the skip count in the operation. */skip?: number; /** When true the skip count is ignored and the action is applied regardless of the skip count */
-  ignoreSkipOperations?: boolean; /** if true reuses the provided action resulting state instead of replaying it */
-  reuseOperationResultingState?: boolean; /** if true checks the hashes of the operations */
-  checkHashes?: boolean; /** Options for performing a replay. */
-  replayOptions?: {
-    /** The previously created operation to verify against. */operation: Operation;
-  }; /** Optional parser for the operation resulting state, uses JSON.parse by default */
-  operationResultingStateParser?: <TState>(state: string | null | undefined) => TState;
-  /**
-   * When true (default), the reducer will prune operations (garbage collect) when processing a skip.
-   * When false, it will recompute state for the skip but preserve the existing operations history.
-   */
-  pruneOnSkip?: boolean; /** The branch being operated on. Defaults to "main". */
-  branch?: string;
-  /**
-   * Protocol version controlling undo/redo behavior.
-   * - Version 1 (default): Legacy behavior with index reuse
-   * - Version 2: Reactor behavior with monotonic indices
-   */
-  protocolVersion?: number;
-  /**
-   * When true, skip index contiguity validation during replay.
-   * Used for V2 state rebuild where gapped indices are expected.
-   */
-  skipIndexValidation?: boolean;
+type MutationUndoArgs = {
+  input: SchemaUndoAction;
 };
-/**
- * A pure function that takes an action and the previous state
- * of the document and returns the new state.
- */
-type Reducer<TState extends PHBaseState = PHBaseState> = (document: PHDocument<TState>, action: Action, dispatch?: SignalDispatch, options?: ReducerOptions) => PHDocument<TState>;
-type StateReducer<TState extends PHBaseState = PHBaseState> = (state: Draft<TState>, action: Action, dispatch?: SignalDispatch) => TState | undefined;
-/**
- * Object that indexes attachments of a Document.
- *
- * @remarks
- * This is used to reduce memory usage to avoid
- * multiple instances of the binary data of the attachments.
- *
- */
-type FileRegistry = Record<AttachmentRef, Attachment>;
-type MappedOperation = {
-  ignore: boolean;
-  operation: Operation;
+type Prune = "PRUNE";
+type SchemaPruneAction = {
+  id: Scalars["String"]["output"];
+  timestampUtcMs: Scalars["DateTime"]["output"];
+  input: PruneActionInput;
+  type: Prune;
+  scope: string;
 };
-type DocumentOperationsIgnoreMap = Record<string, MappedOperation[]>;
-type ActionSignatureContext = {
-  documentId: string;
-  signer: ActionSigner;
-  action: Action;
-  previousStateHash: string;
+type PruneActionInput = {
+  end?: InputMaybe<Scalars["Int"]["input"]>;
+  start?: InputMaybe<Scalars["Int"]["input"]>;
 };
-type ActionSigningHandler = (message: Uint8Array) => Promise<Uint8Array>;
-type ActionVerificationHandler = (publicKey: string, signature: Uint8Array, data: Uint8Array) => Promise<boolean>;
-/**
- * Handler for verifying operation signatures.
- *
- * @param operation - The operation to verify
- * @param publicKey - The public key to verify against (from signer.app.key)
- * @returns Promise that resolves to true if signature is valid, false otherwise
- */
-type SignatureVerificationHandler = (operation: Operation, publicKey: string) => Promise<boolean>;
-type ENSInfo = {
-  name?: string;
-  avatarUrl?: string;
+type Query = {
+  __typename?: "Query";
+  document: Maybe<IDocument>;
 };
-type User = {
-  address: `0x${string}`;
-  networkId: string;
-  chainId: number;
-  ens?: ENSInfo;
+type Redo = "REDO";
+type RedoActionInput = {
+  count: Scalars["Int"]["input"];
 };
-type PartialRecord<K extends keyof any, T> = { [P in K]?: T };
-type RevisionsFilter = PartialRecord<string, number>;
-type GetDocumentOptions = ReducerOptions & {
-  revisions?: RevisionsFilter;
-  checkHashes?: boolean;
+type SchemaRedoAction = {
+  id: Scalars["String"]["output"];
+  timestampUtcMs: Scalars["DateTime"]["output"];
+  input: RedoActionInput;
+  type: Redo;
+  scope: string;
 };
-type ActionErrorCallback = (error: unknown) => void;
-type EditorDispatch = (action: Action, onErrorCallback?: ActionErrorCallback) => void;
-type EditorProps = {
-  children?: ReactNode;
-  className?: string;
-  document?: PHDocument;
+type Set_Name = "SET_NAME";
+type SetNameActionInput = {
+  name: Scalars["String"]["input"];
 };
-type SubgraphModule = {
-  id: string;
-  name: string;
-  gql: string;
-  endpoint: string;
+type SchemaSetNameAction = {
+  id: Scalars["String"]["output"];
+  timestampUtcMs: Scalars["DateTime"]["output"];
+  input: SetNameActionInput;
+  type: Set_Name;
+  scope: "global";
 };
-type EditorModule<TProps = any> = {
-  Component: FC<EditorProps & TProps>;
-  documentTypes: string[];
-  config: {
-    id: string;
-    name: string;
-  };
+type SetNameOperation = IOperation & {
+  __typename?: "SetNameOperation";
+  hash: Scalars["String"]["output"];
+  index: Scalars["Int"]["output"];
+  input: Scalars["String"]["output"];
+  timestamp: Scalars["DateTime"]["output"];
+  type: Scalars["String"]["output"];
 };
-type ValidationError = {
-  message: string;
-  details: object;
+type Set_PreferredEditor = "SET_PREFERRED_EDITOR";
+type SetPreferredEditorActionInput = {
+  preferredEditor: Scalars["String"]["input"] | null;
 };
-type SkipHeaderOperations = Partial<Record<string, number>>;
-type ReplayDocumentOptions = {
-  checkHashes?: boolean;
-  reuseOperationResultingState?: boolean;
-  operationResultingStateParser?: <TState>(state: string) => TState;
-  skipIndexValidation?: boolean;
+type SchemaSetPreferredEditorAction = {
+  id: Scalars["String"]["output"];
+  timestampUtcMs: Scalars["DateTime"]["output"];
+  input: SetPreferredEditorActionInput;
+  type: Set_PreferredEditor;
+  scope: "header";
 };
-type OperationIndex = {
-  index: number;
-  skip: number;
-  id?: string;
-  timestampUtcMs?: string;
+type SetPreferredEditorOperation = IOperation & {
+  __typename?: "SetPreferredEditorOperation";
+  hash: Scalars["String"]["output"];
+  index: Scalars["Int"]["output"];
+  input: SetPreferredEditorActionInput;
+  timestamp: Scalars["DateTime"]["output"];
+  type: Scalars["String"]["output"];
 };
-/**
- * Parameters used in a document signature.
- */
-type SigningParameters = {
-  documentType: string;
-  createdAtUtcIso: string;
-  /**
-   * The nonce can act as both a salt and a typical nonce.
-   */
-  nonce: string;
+type Undo = "UNDO";
+type UndoActionInput = {
+  count: Scalars["Int"]["input"];
 };
-/**
- * Describes a signer that can sign both document headers and actions.
- */
-interface ISigner {
-  /** The user associated with the signer */
-  user?: UserActionSigner;
-  /** The app associated with the signer */
-  app?: AppActionSigner;
-  /** The corresponding public key */
-  publicKey: CryptoKey;
-  /**
-   * Signs raw data (used for document header signing).
-   *
-   * @param data - The data to sign.
-   * @returns The signature of the data.
-   */
-  sign: (data: Uint8Array) => Promise<Uint8Array>;
-  /**
-   * Verifies a signature.
-   *
-   * @param data - The data to verify.
-   * @param signature - The signature to verify.
-   */
-  verify: (data: Uint8Array, signature: Uint8Array) => Promise<void>;
-  /**
-   * Signs an action (used for operation signing).
-   *
-   * @param action - The action to sign.
-   * @param abortSignal - Optional abort signal to cancel the signing.
-   * @returns The signature tuple.
-   */
-  signAction: (action: Action, abortSignal?: AbortSignal) => Promise<Signature>;
-}
-type IsStateOfType<TState> = (state: unknown) => state is TState;
-type AssertIsStateOfType<TState> = (state: unknown) => asserts state is TState;
-type IsDocumentOfType<TState extends PHBaseState> = (document: unknown) => document is PHDocument<TState>;
-type AssertIsDocumentOfType<TState extends PHBaseState> = (document: unknown) => asserts document is PHDocument<TState>;
-type PartialState<TState> = TState | Partial<TState>;
-type CreateState<TState extends PHBaseState = PHBaseState> = (state?: PartialState<TState>) => TState;
-type SaveToFileHandle = (document: PHDocument, input: FileSystemFileHandle) => void | Promise<void>;
-type SaveToFile = (document: PHDocument, path: string, name?: string) => string | Promise<string>;
-type LoadFromInput<TState extends PHBaseState = PHBaseState> = (input: FileInput) => PHDocument<TState> | Promise<PHDocument<TState>>;
-type LoadFromFile<TState extends PHBaseState = PHBaseState> = (path: string) => PHDocument<TState> | Promise<PHDocument<TState>>;
-type CreateDocument<TState extends PHBaseState = PHBaseState> = (initialState?: Partial<TState>, createState?: CreateState<TState>) => PHDocument<TState>;
-type MinimalBackupData = {
-  documentId: string;
-  documentType: string;
-  branch: string;
-  state: PHBaseState;
-  name: string;
+type SchemaUndoAction = {
+  id: Scalars["String"]["output"];
+  timestampUtcMs: Scalars["DateTime"]["output"];
+  input: UndoActionInput;
+  type: Undo;
+  scope: string;
 };
-type DocumentModelUtils<TState extends PHBaseState = PHBaseState> = {
-  fileExtension: string;
-  createState: CreateState<TState>;
-  createDocument: CreateDocument<TState>;
-  loadFromInput: LoadFromInput<TState>;
-  saveToFileHandle: SaveToFileHandle;
-  isStateOfType: IsStateOfType<TState>;
-  assertIsStateOfType: AssertIsStateOfType<TState>;
-  isDocumentOfType: IsDocumentOfType<TState>;
-  assertIsDocumentOfType: AssertIsDocumentOfType<TState>;
+type SchemaNOOPAction = {
+  id: Scalars["String"]["output"];
+  input: Scalars["Unknown"]["input"];
+  scope: string;
+  timestampUtcMs: Scalars["DateTime"]["output"];
+  type: "NOOP";
 };
-type Actions = Record<string, (...args: any[]) => Action>;
-type DocumentModelModule<TState extends PHBaseState = PHBaseState> = {
-  /** optional version field, should be made required */version?: number;
-  reducer: Reducer<TState>;
-  actions: Actions;
-  utils: DocumentModelUtils<TState>;
-  documentModel: DocumentModelPHState;
+type LoadStateAction = Action & {
+  type: "LOAD_STATE";
+  input: LoadStateActionInput;
 };
-type DocumentModelLib<TState extends PHBaseState = PHBaseState> = {
-  manifest: Manifest;
-  documentModels: readonly DocumentModelModule<TState>[];
-  editors: readonly EditorModule[];
-  subgraphs?: readonly SubgraphModule[];
-  upgradeManifests?: readonly UpgradeManifest<readonly number[]>[] | undefined;
-  processorFactory?: ProcessorFactoryBuilder;
+type PruneAction = Action & {
+  type: "PRUNE";
+  input: PruneActionInput;
 };
-type DocumentModelDocumentModelModule = DocumentModelModule<DocumentModelPHState>;
-type ConfigEntryType = z.infer<typeof ConfigEntryTypeSchema>;
-type ConfigEntry = z.infer<typeof ConfigEntrySchema>;
-type PowerhouseModule = z.infer<typeof PowerhouseModuleSchema>;
-type Publisher = z.infer<typeof PublisherSchema>;
-type Manifest = z.infer<typeof ManifestSchema>;
-//#endregion
-//#region document-model/state.d.ts
-/**
- * Creates a default PHAuthState
- */
-declare function defaultAuthState(): PHAuthState;
-/**
- * Creates a default PHDocumentState
- */
-declare function defaultDocumentState(): PHDocumentState;
-/**
- * Creates a default PHBaseState with auth and document properties
- */
-declare function defaultBaseState(): PHBaseState;
-/**
- * Creates a PHAuthState with the given properties
- */
-declare function createAuthState(auth?: Partial<PHAuthState>): PHAuthState;
-/**
- * Creates a PHDocumentState with the given properties
- */
-declare function createDocumentState(document?: Partial<PHDocumentState>): PHDocumentState;
-/**
- * Creates a PHBaseState with the given auth and document properties
- */
-declare function createBaseState(auth?: Partial<PHAuthState>, document?: Partial<PHDocumentState>): PHBaseState;
-/**
- * The document state of the document.
- */
-type PHDocumentState = {
-  /**
-   * The current document model schema version of the document. This is used
-   * with the UPGRADE_DOCUMENT operation to specify the DocumentModelModule
-   * version to use for reducer execution.
-   */
-  version: number; /** Hash configuration for operation state verification */
-  hash: HashConfig; /** True if and only if the document has been deleted */
-  isDeleted?: boolean; /** The timestamp when the document was deleted, in UTC ISO format */
-  deletedAtUtcIso?: string; /** Optional: who deleted the document */
-  deletedBy?: string; /** Optional: reason for deletion */
-  deletionReason?: string;
+type RedoAction = Action & {
+  type: "REDO";
+  input: SchemaRedoAction["input"];
 };
-/**
- * The authentication state of the document.
- *
- * This has yet to be implemented.
- */
-type PHAuthState = {};
-/**
- * The base state of the document.
- */
-type PHBaseState = {
-  /** Carries authentication information. */auth: PHAuthState; /** Carries information about the document. */
-  document: PHDocumentState;
+type SetNameAction = Action & {
+  type: "SET_NAME";
+  input: SchemaSetNameAction["input"];
 };
-declare function defaultGlobalState(): DocumentModelGlobalState;
-declare function defaultLocalState(): DocumentModelLocalState;
-declare function defaultPHState(): DocumentModelPHState;
-declare function createGlobalState(state?: Partial<DocumentModelGlobalState>): DocumentModelGlobalState;
-declare function createLocalState(state?: Partial<DocumentModelLocalState>): DocumentModelLocalState;
-declare function createState(baseState?: Partial<PHBaseState>, globalState?: Partial<DocumentModelGlobalState>, localState?: Partial<DocumentModelLocalState>): DocumentModelPHState;
-//#endregion
-//#region document-model/operations.d.ts
-declare function setNameOperation<TDocument extends PHDocument>(document: TDocument, input: {
-  name: string;
-}): TDocument & {
-  header: {
-    name: string;
-    id: string;
-    sig: PHDocumentSignatureInfo;
-    documentType: string;
+type SetPreferredEditorAction = Action & {
+  type: "SET_PREFERRED_EDITOR";
+  input: SchemaSetPreferredEditorAction["input"];
+};
+type UndoAction = Action & {
+  type: "UNDO";
+  input: SchemaUndoAction["input"];
+};
+type NOOPAction = Action & {
+  type: "NOOP";
+  input: SchemaNOOPAction["input"];
+};
+type CreateDocumentActionInput = {
+  model: string;
+  version: 0;
+  documentId: string;
+  signing?: {
+    signature: string;
+    publicKey: JsonWebKey;
+    nonce: string;
     createdAtUtcIso: string;
-    slug: string;
-    branch: string;
-    revision: {
-      [scope: string]: number;
-    };
-    lastModifiedAtUtcIso: string;
-    protocolVersions?: {
-      [key: string]: number;
-    };
-    meta?: PHDocumentMeta;
+    documentType: string;
+  };
+  slug?: string;
+  name?: string;
+  branch?: string;
+  meta?: Record<string, unknown>;
+  protocolVersions?: {
+    [key: string]: number;
   };
 };
-declare function setPreferredEditorOperation<TDocument extends PHDocument>(document: TDocument, input: {
-  preferredEditor: string | null;
-}): TDocument;
-declare function undoOperation<TDocument extends PHDocument>(document: TDocument, action: Action, skip: number): {
-  document: TDocument;
-  action: Action;
-  skip: number;
-  reuseLastOperationIndex: boolean;
+type UpgradeDocumentActionInput = {
+  model: string;
+  fromVersion: number;
+  toVersion: number;
+  documentId: string;
+  initialState?: object;
 };
-/**
- * V2 of undoOperation for protocol version 2+.
- * Key differences from undoOperation:
- * - Never reuses operation index (always increments)
- * - Always sets skip=1 (consecutive NOOPs are handled during rebuild/GC)
- * - No complex skip calculation - simpler model where each UNDO is independent
- */
-declare function undoOperationV2<TDocument extends PHDocument>(document: TDocument, action: Action, skip: number): {
-  document: TDocument;
-  action: Action;
-  skip: number;
-  reuseLastOperationIndex: false;
+type DeleteDocumentActionInput = {
+  documentId: string;
+  propagate?: "none" | "cascade";
 };
-declare function redoOperation<TDocument extends PHDocument>(document: TDocument, action: Action, skip: number): {
-  document: TDocument;
-  action: Action;
-  skip: number;
-  reuseLastOperationIndex: boolean;
+type AddRelationshipActionInput = {
+  sourceId: string;
+  targetId: string;
+  relationshipType: string;
+  metadata?: Record<string, unknown>;
 };
-declare function loadStateOperation<TState extends PHBaseState>(document: PHDocument<TState>, action: LoadStateActionInput): PHDocument<TState>;
-/**
- * An operation that was applied to a {@link BaseDocument}.
- *
- * @remarks
- * Wraps an action with an index, to be added to the operations history of a Document.
- * The `index` field is used to keep all operations in order and enable replaying the
- * document's history from the beginning. Note that indices and skips are relative to
- * a specific reactor. Example below:
- *
- * For (index, skip, ts, action)
- * A - [(0, 0, 1, "A0"), (1, 0, 2, "A1")]
- * B - [(0, 0, 0, "B0"), (1, 0, 3, "B1")]
- * ...
- * B gets A's Operations Scenario:
- * B' - [(0, 0, 0, "B0"), (1, 0, 3, "B1"), (2, 1, 1, "A0"), (3, 0, 2, "A1"), (4, 0, 3, "B1")]
- * Then A needs to end up with:
- * A' - [(0, 0, 1, "A0"), (1, 0, 2, "A1"), (2, 2, 0, "B0"), (3, 0, 1, "A0"), (4, 0, 2, "A1"), (5, 0, 3, "B1")]
- * So that both A and B end up with the stream of actions (action):
- * [("B0"), ("A0"), ("A1"), ("B1")]
- *
- * @typeParam A - The type of the action.
- */
-type Operation = {
-  /**
-   * This is a stable id, derived from various document and action properties
-   * in deriveOperationId().
-   *
-   * It _cannot_ be an arbitrary string.
-   *
-   * It it also not unique per operation, as reshuffled operations will keep'
-   * the same id they had before they were reshuffled. This means that the
-   * IOperationStore may have multiple operations with the same operation id.
-   **/
-  id: string; /** Position of the operation in the history. This is relative to a specific reactor -- they may not all agree on this value. */
-  index: number; /** The number of operations skipped with this Operation. This is relative to a specific reactor -- they may not all agree on this value. */
-  skip: number; /** Timestamp of when the operation was added */
-  timestampUtcMs: string; /** Hash of the resulting document data after the operation */
-  hash: string; /** Error message for a failed action */
-  error?: string; /** The resulting state after the operation */
-  resultingState?: string;
-  /**
-   * The action that was applied to the document to produce this operation.
-   */
-  action: Action;
+type RemoveRelationshipActionInput = {
+  sourceId: string;
+  targetId: string;
+  relationshipType: string;
+};
+type UpdateRelationshipActionInput = {
+  sourceId: string;
+  targetId: string;
+  relationshipType: string;
+  metadata: Record<string, unknown> | null;
+};
+type CreateDocumentAction = Action & {
+  type: "CREATE_DOCUMENT";
+  input: CreateDocumentActionInput;
 };
-/**
- * The operations history of the document by scope.
- *
- * This will be removed in a future release.
- *
- * TODO: Type should be Partial<Record<string, Operation[]>>,
- * but that is a breaking change for codegen + external doc models.
- */
-type DocumentOperations = Record<string, Operation[]>;
-type OperationContext = {
-  documentId: string;
-  documentType: string;
-  scope: string;
-  branch: string;
-  resultingState?: string;
-  ordinal: number;
+type UpgradeDocumentAction = Action & {
+  type: "UPGRADE_DOCUMENT";
+  input: UpgradeDocumentActionInput;
 };
-type OperationWithContext$1 = {
-  operation: Operation;
-  context: OperationContext;
+type DeleteDocumentAction = Action & {
+  type: "DELETE_DOCUMENT";
+  input: DeleteDocumentActionInput;
 };
-//#endregion
-//#region document-model/documents.d.ts
-/** Meta information about the document. */
-type PHDocumentMeta = {
-  /** The preferred editor for the document. */preferredEditor?: string;
+type AddRelationshipAction = Action & {
+  type: "ADD_RELATIONSHIP";
+  input: AddRelationshipActionInput;
 };
-/**
- * The header of a document.
- */
-type PHDocumentHeader = {
-  /**
-   * The id of the document.
-   *
-   * This is a Ed25519 signature and is immutable.
-   **/
-  id: string;
-  /**
-   * Information to verify the document creator.
-   *
-   * This is immutable.
-   **/
-  sig: PHDocumentSignatureInfo;
-  /**
-   * The type of the document.
-   *
-   * This is used as part of the signature payload and thus, cannot be changed
-   * after the document header has been created.
-   **/
-  documentType: string;
-  /**
-   * The timestamp of the creation date of the document, in UTC ISO format.
-   *
-   * This is used as part of the signature payload and thus, cannot be changed
-   * after the document header has been created.
-   **/
-  createdAtUtcIso: string; /** The slug of the document. */
-  slug: string; /** The name of the document. */
-  name: string; /** The branch of this document. */
-  branch: string;
-  /**
-   * The revision of each scope of the document. This object is updated every
-   * time any _other_ scope is updated.
-   */
-  revision: {
-    [scope: string]: number;
-  };
-  /**
-   * The timestamp of the last change in the document, in UTC ISO format.
-   **/
-  lastModifiedAtUtcIso: string;
-  /**
-   * This is a map from protocol name to version. A protocol can be any set of
-   * rules that are applied to the document.
-   *
-   * Examples of protocols include:
-   *
-   * - "base-reducer"
-   */
-  protocolVersions?: {
-    [key: string]: number;
-  }; /** Meta information about the document. */
-  meta?: PHDocumentMeta;
+type RemoveRelationshipAction = Action & {
+  type: "REMOVE_RELATIONSHIP";
+  input: RemoveRelationshipActionInput;
 };
-/**
- * The base type of a document model.
- *
- * @remarks
- * This type is extended by all Document models.
- *
- * @typeParam TState - The type of the document state.
- */
-type PHDocument<TState extends PHBaseState = PHBaseState> = {
-  /** The header of the document. */header: PHDocumentHeader; /** The document model specific state. */
-  state: TState;
-  /**
-   * The initial state of the document, enabling replaying operations.
-   *
-   * This will be removed in a future release.
-   */
-  initialState: TState;
-  /**
-   * The operations history of the document.
-   *
-   * This will be removed in a future release.
-   */
-  operations: DocumentOperations;
-  /**
-   * A list of undone operations
-   *
-   * This will be removed in a future release.
-   */
-  clipboard: Operation[];
+type UpdateRelationshipAction = Action & {
+  type: "UPDATE_RELATIONSHIP";
+  input: UpdateRelationshipActionInput;
 };
-declare function isNoopOperation<TOp extends {
-  type: string;
-  skip: number;
-  hash: string;
-}>(op: Partial<TOp>): boolean;
-declare function isUndoRedo(action: Action): action is UndoRedoAction;
-declare function isUndo(action: Action): action is UndoAction;
-declare function isDocumentAction(action: Action): action is DocumentAction;
-/**
- * Creates a new document. When `documentType` is given the header is stamped
- * with it and the document-scope operations are seeded.
- */
-declare function baseCreateDocument<TState extends PHBaseState = PHBaseState>(createState: CreateState<TState>, initialState?: Partial<TState>, documentType?: string): PHDocument<TState>;
-declare function hashDocumentStateForScope(document: {
-  state: {
-    [key: string]: unknown;
-  };
-}, scope?: string): string;
-declare function readOnly<T>(value: T): Readonly<T>;
-/**
- * Maps skipped operations in an array of operations.
- * Skipped operations are operations that are ignored during processing.
- * @param operations - The array of operations to map.
- * @param skippedHeadOperations - The number of operations to skip at the head of the array of operations.
- * @returns An array of mapped operations with ignore flag indicating if the operation is skipped.
- * @throws Error if the operation index is invalid and there are missing operations.
- */
-declare function mapSkippedOperations(operations: Operation[], skippedHeadOperations?: number): MappedOperation[];
-/**
- * V2 version of mapSkippedOperations for protocol version 2+.
- * In V2, all NOOPs have skip=1 and consecutive NOOPs form chains.
- * N consecutive NOOPs at any point skip N preceding content operations.
- *
- * Algorithm: Process from end to start
- * - When hitting a NOOP: increment chain length, mark as ignored
- * - When hitting a non-NOOP:
- *   - If chain > 0: decrement chain, mark as ignored (this op was undone)
- *   - If chain == 0: mark as not ignored (apply this op)
- */
-declare function mapSkippedOperationsV2(operations: Operation[]): MappedOperation[];
-/**
- * V2 garbage collect that returns only operations that should be applied for state.
- * Uses the V2 model where consecutive NOOPs form chains.
- * Unlike V1 garbageCollect, this preserves ALL operations but marks which to apply.
- */
-declare function garbageCollectV2<TOpIndex extends OperationIndex>(sortedOperations: TOpIndex[]): TOpIndex[];
-declare function sortMappedOperations(operations: DocumentOperationsIgnoreMap): MappedOperation[];
-declare function replayDocument<TState extends PHBaseState = PHBaseState>(initialState: TState, operations: DocumentOperations, reducer: Reducer<TState>, header: PHDocumentHeader, dispatch?: SignalDispatch, skipHeaderOperations?: SkipHeaderOperations, options?: ReplayDocumentOptions): PHDocument<TState>;
-declare function parseResultingState<TState>(state: string | null | undefined): TState;
-declare enum IntegrityIssueType {
-  UNEXPECTED_INDEX = "UNEXPECTED_INDEX"
-}
-declare enum IntegrityIssueSubType {
-  DUPLICATED_INDEX = "DUPLICATED_INDEX",
-  MISSING_INDEX = "MISSING_INDEX"
+type DocumentAction = LoadStateAction | PruneAction | RedoAction | SetNameAction | SetPreferredEditorAction | UndoAction | NOOPAction;
+interface ISignal<TType extends string, TInput> {
+  type: TType;
+  input: TInput;
 }
-type IntegrityIssue = {
-  operation: OperationIndex;
-  issue: IntegrityIssueType;
-  category: IntegrityIssueSubType;
-  message: string;
-};
-type Reshuffle = (startIndex: OperationIndex, opsA: Operation[], opsB: Operation[]) => Operation[];
-declare function checkCleanedOperationsIntegrity(sortedOperations: OperationIndex[]): IntegrityIssue[];
-declare function garbageCollect<TOpIndex extends OperationIndex>(sortedOperations: TOpIndex[]): TOpIndex[];
-declare function addUndo(sortedOperations: Operation[]): Operation[];
-declare function sortOperations<TOpIndex extends OperationIndex>(operations: TOpIndex[]): TOpIndex[];
-declare function reshuffleByTimestamp<TOp extends OperationIndex>(startIndex: OperationIndex, opsA: TOp[], opsB: TOp[]): TOp[];
-declare function reshuffleByTimestampAndIndex<TOp extends OperationIndex>(startIndex: OperationIndex, opsA: TOp[], opsB: TOp[]): TOp[];
-declare function operationsAreEqual<TOp extends {
-  index: number;
-  skip: number;
-  type?: string;
-  scope?: string;
-  input?: unknown;
-}>(op1: TOp, op2: TOp): boolean;
-declare function attachBranch(trunk: Operation[], newBranch: Operation[]): [Operation[], Operation[]];
-declare function precedes(op1: OperationIndex, op2: OperationIndex): boolean;
-declare function split(sortedTargetOperations: Operation[], sortedMergeOperations: Operation[]): [Operation[], Operation[], Operation[]];
-declare function merge(sortedTargetOperations: Operation[], sortedMergeOperations: Operation[], reshuffle: Reshuffle): Operation[];
-declare function nextSkipNumber(sortedOperations: OperationIndex[]): number;
-declare function checkOperationsIntegrity(operations: Operation[]): IntegrityIssue[];
-declare function groupOperationsByScope(operations: Operation[]): Partial<Record<string, Operation[]>>;
-type PrepareOperationsResult = {
-  validOperations: Operation[];
-  invalidOperations: Operation[];
-  duplicatedOperations: Operation[];
-  integrityIssues: IntegrityIssue[];
+type ISignalResult<TTYpe, TInput, TResult> = {
+  signal: {
+    type: TTYpe;
+    input: TInput;
+  };
+  result: TResult;
 };
-declare function prepareOperations(operationsHistory: Operation[], newOperations: Operation[]): PrepareOperationsResult;
-declare function removeExistingOperations(newOperations: Operation[], operationsHistory: Operation[]): Operation[];
-/**
- * Skips header operations and returns the remaining operations.
- *
- * @param operations - The array of operations.
- * @param skipHeaderOperation - The skip header operation index.
- * @returns The remaining operations after skipping header operations.
- */
-declare function skipHeaderOperations(operations: Operation[], skipHeaderOperation: SkipHeaderOperationIndex): Operation[];
-declare function garbageCollectDocumentOperations(documentOperations: DocumentOperations): DocumentOperations;
-/**
- * Filters out duplicated operations from the target operations array based on their IDs.
- * If an operation has an ID, it is considered duplicated if there is another operation in the source operations array with the same ID.
- * If an operation does not have an ID, it is considered unique and will not be filtered out.
- * @param targetOperations - The array of target operations to filter.
- * @param sourceOperations - The array of source operations to compare against.
- * @returns An array of operations with duplicates filtered out.
- */
-declare function filterDuplicatedOperations<T extends {
-  id?: string | number;
-}>(targetOperations: T[], sourceOperations: T[]): T[];
-declare function filterDocumentOperationsResultingState(documentOperations?: DocumentOperations): {
-  [x: string]: Operation[] | {
-    id: string;
-    index: number;
-    skip: number;
-    timestampUtcMs: string;
-    hash: string;
-    error?: string;
-    action: Action;
-  }[];
+type CreateChildDocumentInput = {
+  id: string;
+  documentType: string;
+};
+type CreateChildDocumentSignal = ISignal<"CREATE_CHILD_DOCUMENT", CreateChildDocumentInput>;
+type DeleteChildDocumentInput = {
+  id: string;
+};
+type DeleteChildDocumentSignal = ISignal<"DELETE_CHILD_DOCUMENT", DeleteChildDocumentInput>;
+type CopyChildDocumentInput = {
+  id: string;
+  newId: string;
+};
+type CopyChildDocumentSignal = ISignal<"COPY_CHILD_DOCUMENT", CopyChildDocumentInput>;
+type Signal = CreateChildDocumentSignal | CopyChildDocumentSignal | DeleteChildDocumentSignal;
+type SignalDispatch = (signal: Signal) => void;
+type SignalResult = ISignalResult<CreateChildDocumentSignal["type"], CreateChildDocumentSignal["input"], PHDocument> | ISignalResult<CopyChildDocumentSignal["type"], CopyChildDocumentSignal["input"], boolean> | ISignalResult<DeleteChildDocumentSignal["type"], DeleteChildDocumentSignal["input"], PHDocument>;
+type SignalResults = {
+  CREATE_CHILD_DOCUMENT: PHDocument;
+  COPY_CHILD_DOCUMENT: PHDocument;
+  DELETE_CHILD_DOCUMENT: boolean;
+};
+type SignalType<T extends Signal> = T["type"];
+type FileInput = string | number[] | Uint8Array | ArrayBuffer | Blob;
+type ReducerOptions = {
+  /** The number of operations to skip before this new action is applied. This overrides the skip count in the operation. */skip?: number; /** When true the skip count is ignored and the action is applied regardless of the skip count */
+  ignoreSkipOperations?: boolean; /** if true reuses the provided action resulting state instead of replaying it */
+  reuseOperationResultingState?: boolean; /** if true checks the hashes of the operations */
+  checkHashes?: boolean; /** Options for performing a replay. */
+  replayOptions?: {
+    /** The previously created operation to verify against. */operation: Operation;
+  }; /** Optional parser for the operation resulting state, uses JSON.parse by default */
+  operationResultingStateParser?: <TState>(state: string | null | undefined) => TState;
+  /**
+   * When true (default), the reducer will prune operations (garbage collect) when processing a skip.
+   * When false, it will recompute state for the skip but preserve the existing operations history.
+   */
+  pruneOnSkip?: boolean; /** The branch being operated on. Defaults to "main". */
+  branch?: string;
+  /**
+   * Protocol version controlling undo/redo behavior.
+   * - Version 1 (default): Legacy behavior with index reuse
+   * - Version 2: Reactor behavior with monotonic indices
+   */
+  protocolVersion?: number;
+  /**
+   * When true, skip index contiguity validation during replay.
+   * Used for V2 state rebuild where gapped indices are expected.
+   */
+  skipIndexValidation?: boolean;
 };
 /**
- * Calculates the difference between two arrays of operations.
- * Returns an array of operations that are present in `clearedOperationsA` but not in `clearedOperationsB`.
- *
- * @template TOp - The type of the operations.
- * @param {TOp[]} clearedOperationsA - The first array of operations.
- * @param {TOp[]} clearedOperationsB - The second array of operations.
- * @returns {TOp[]} - The difference between the two arrays of operations.
- */
-declare function diffOperations<TOp extends OperationIndex>(clearedOperationsA: TOp[], clearedOperationsB: TOp[]): TOp[];
-declare function getDocumentLastModified(document: PHDocument): string;
-/**
- * Updates the document header with the latest revision number and
- * date of last modification.
- *
- * @param document The current state of the document.
- * @param scope The scope of the operation.
- * @param lastModifiedTimestamp Optional timestamp to use directly, avoiding a scan of all operations.
- * @returns The updated document state.
- */
-declare function updateHeaderRevision(document: PHDocument, scope: string, lastModifiedTimestamp?: string): PHDocument;
-//#endregion
-//#region document-model/actions.d.ts
-/**
- * Cancels the last `count` operations.
- *
- * @param count - Number of operations to cancel
- * @category Actions
- */
-declare const undo: (count?: number, scope?: string) => UndoAction;
-/**
- * Cancels the last `count` {@link undo | UNDO} operations.
- *
- * @param count - Number of UNDO operations to cancel
- * @category Actions
- */
-declare const redo: (count?: number, scope?: string) => RedoAction;
-/**
- * Joins multiple operations into a single {@link loadState | LOAD_STATE} operation.
- *
- * @remarks
- * Useful to keep operations history smaller. Operations to prune are selected by index,
- * similar to the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice | slice} method in Arrays.
- *
- * @param start - Index of the first operation to prune
- * @param end - Index of the last operation to prune
- * @category Actions
- */
-declare const prune: (start?: number, end?: number, scope?: string) => SchemaPruneAction;
-/**
- * Replaces the state of the document.
- *
- * @remarks
- * This action shouldn't be used directly. It is dispatched by the {@link prune} action.
- *
- * @param state - State to be set in the document.
- * @param operations - Number of operations that were removed from the previous state.
- * @category Actions
+ * A pure function that takes an action and the previous state
+ * of the document and returns the new state.
  */
-declare const loadState: <TState extends PHBaseState = PHBaseState>(state: TState & {
-  name: string;
-}, operations: number) => LoadStateAction;
-declare const noop: (scope?: string) => NOOPAction;
+type Reducer<TState extends PHBaseState = PHBaseState> = (document: PHDocument<TState>, action: Action, dispatch?: SignalDispatch, options?: ReducerOptions) => PHDocument<TState>;
+type StateReducer<TState extends PHBaseState = PHBaseState> = (state: Draft<TState>, action: Action, dispatch?: SignalDispatch) => TState | undefined;
 /**
- * Helper function to be used by action creators.
+ * Object that indexes attachments of a Document.
  *
  * @remarks
- * Creates an action with the given type and input properties. The input
- * properties default to an empty object.
- *
- * @typeParam A - Type of the action to be returned.
- *
- * @param type - The type of the action.
- * @param input - The input properties of the action.
- * @param attachments - The attachments included in the action.
- * @param validator - The validator to use for the input properties.
- * @param scope - The scope of the action, can either be 'global' or 'local'.
- * @param skip - The number of operations to skip before this new action is applied.
- *
- * @throws Error if the type is empty or not a string.
- *
- * @returns The new action.
- */
-declare function createAction<TAction extends Action>(type: TAction["type"], input?: TAction["input"], attachments?: TAction["attachments"], validator?: () => {
-  parse(v: unknown): TAction["input"];
-}, scope?: Action["scope"]): TAction;
-/**
- * This function should be used instead of { ...action } to ensure
- * that extra properties are not included in the action.
- */
-declare const actionFromAction: (action: Action) => Action;
-declare const operationFromAction: (action: Action, index: number, skip: number, context: OperationContext) => Operation;
-declare const operationFromOperation: (operation: Operation, index: number, skip: number, context: OperationContext) => Operation;
-declare const operationWithContext: (operation: Operation, context: ActionContext) => Operation;
-declare const actionContext: () => ActionContext;
-declare const actionSigner: (user: UserActionSigner, app: AppActionSigner, signatures?: Signature[]) => ActionSigner;
-declare function buildOperationSignature(context: ActionSignatureContext, signMethod: ActionSigningHandler): Promise<Signature>;
-declare function buildSignedAction<TState extends PHBaseState = PHBaseState>(action: Action, reducer: Reducer<TState>, document: PHDocument<TState>, signer: ActionSigner, signHandler: ActionSigningHandler): Promise<Operation>;
-declare function verifyOperationSignature(signature: Signature, signer: Omit<ActionSigner, "signatures">, verifyHandler: ActionVerificationHandler): Promise<boolean>;
-/**
- * Changes the name of the document.
+ * This is used to reduce memory usage to avoid
+ * multiple instances of the binary data of the attachments.
  *
- * @param name - The name to be set in the document.
- * @category Actions
  */
-declare const setName: (name: string | {
-  name: string;
-}) => SetNameAction;
+type FileRegistry = Record<AttachmentRef, Attachment>;
+type MappedOperation = {
+  ignore: boolean;
+  operation: Operation;
+};
+type DocumentOperationsIgnoreMap = Record<string, MappedOperation[]>;
+type ActionSignatureContext = {
+  documentId: string;
+  signer: ActionSigner;
+  action: Action;
+  previousStateHash: string;
+};
+type ActionSigningHandler = (message: Uint8Array) => Promise<Uint8Array>;
+type ActionVerificationHandler = (publicKey: string, signature: Uint8Array, data: Uint8Array) => Promise<boolean>;
 /**
- * Changes the preferred editor recorded in the document header meta.
- *
- * Passing `null` clears the preferred editor.
+ * Handler for verifying operation signatures.
  *
- * @category Actions
+ * @param operation - The operation to verify
+ * @param publicKey - The public key to verify against (from signer.app.key)
+ * @returns Promise that resolves to true if signature is valid, false otherwise
  */
-declare const setPreferredEditor: (input: string | null | {
-  preferredEditor: string | null;
-}) => SetPreferredEditorAction;
-declare const setModelName: (input: SetModelNameInput) => SetModelNameAction;
-declare const setModelId: (input: SetModelIdInput) => SetModelIdAction;
-declare const setModelExtension: (input: SetModelExtensionInput) => SetModelExtensionAction;
-declare const setModelDescription: (input: SetModelDescriptionInput) => SetModelDescriptionAction;
-declare const setAuthorName: (input: SetAuthorNameInput) => SetAuthorNameAction;
-declare const setAuthorWebsite: (input: SetAuthorWebsiteInput) => SetAuthorWebsiteAction;
-declare const addModule: (input: AddModuleInput) => AddModuleAction;
-declare const setModuleName: (input: SetModuleNameInput) => SetModuleNameAction;
-declare const setModuleDescription: (input: SetModuleDescriptionInput) => SetModuleDescriptionAction;
-declare const deleteModule: (input: DeleteModuleInput) => DeleteModuleAction;
-declare const reorderModules: (input: ReorderModulesInput) => ReorderModulesAction;
-declare const addOperation: (input: AddOperationInput) => AddOperationAction;
-declare const setOperationName: (input: SetOperationNameInput) => SetOperationNameAction;
-declare const setOperationScope: (input: SetOperationScopeInput) => SetOperationScopeAction;
-declare const setOperationSchema: (input: SetOperationSchemaInput) => SetOperationSchemaAction;
-declare const setOperationDescription: (input: SetOperationDescriptionInput) => SetOperationDescriptionAction;
-declare const setOperationTemplate: (input: SetOperationTemplateInput) => SetOperationTemplateAction;
-declare const setOperationReducer: (input: SetOperationReducerInput) => SetOperationReducerAction;
-declare const moveOperation: (input: MoveOperationInput) => MoveOperationAction;
-declare const deleteOperation: (input: DeleteOperationInput) => DeleteOperationAction;
-declare const reorderModuleOperations: (input: ReorderModuleOperationsInput) => ReorderModuleOperationsAction;
-declare const addOperationError: (input: AddOperationErrorInput) => AddOperationErrorAction;
-declare const setOperationErrorCode: (input: SetOperationErrorCodeInput) => SetOperationErrorCodeAction;
-declare const setOperationErrorName: (input: SetOperationErrorNameInput) => SetOperationErrorNameAction;
-declare const setOperationErrorDescription: (input: SetOperationErrorDescriptionInput) => SetOperationErrorDescriptionAction;
-declare const setOperationErrorTemplate: (input: SetOperationErrorTemplateInput) => SetOperationErrorTemplateAction;
-declare const deleteOperationError: (input: DeleteOperationErrorInput) => DeleteOperationErrorAction;
-declare const reorderOperationErrors: (input: ReorderOperationErrorsInput) => ReorderOperationErrorsAction;
-declare const addOperationExample: (input: AddOperationExampleInput) => AddOperationExampleAction;
-declare const updateOperationExample: (input: UpdateOperationExampleInput) => UpdateOperationExampleAction;
-declare const deleteOperationExample: (input: DeleteOperationExampleInput) => DeleteOperationExampleAction;
-declare const reorderOperationExamples: (input: ReorderOperationExamplesInput) => ReorderOperationExamplesAction;
-declare const operationExampleCreators: {
-  addOperationExample: (input: AddOperationExampleInput) => AddOperationExampleAction;
-  updateOperationExample: (input: UpdateOperationExampleInput) => UpdateOperationExampleAction;
-  deleteOperationExample: (input: DeleteOperationExampleInput) => DeleteOperationExampleAction;
-  reorderOperationExamples: (input: ReorderOperationExamplesInput) => ReorderOperationExamplesAction;
+type SignatureVerificationHandler = (operation: Operation, publicKey: string) => Promise<boolean>;
+type ENSInfo = {
+  name?: string;
+  avatarUrl?: string;
 };
-declare const setStateSchema: (input: SetStateSchemaInput) => SetStateSchemaAction;
-declare const setInitialState: (input: SetInitialStateInput) => SetInitialStateAction;
-declare const addStateExample: (input: AddStateExampleInput) => AddStateExampleAction;
-declare const updateStateExample: (input: UpdateStateExampleInput) => UpdateStateExampleAction;
-declare const deleteStateExample: (input: DeleteStateExampleInput) => DeleteStateExampleAction;
-declare const reorderStateExamples: (input: ReorderStateExamplesInput) => ReorderStateExamplesAction;
-declare const addChangeLogItem: (input: AddChangeLogItemInput) => AddChangeLogItemAction;
-declare const updateChangeLogItem: (input: UpdateChangeLogItemInput) => UpdateChangeLogItemAction;
-declare const deleteChangeLogItem: (input: DeleteChangeLogItemInput) => DeleteChangeLogItemAction;
-declare const reorderChangeLogItems: (input: ReorderChangeLogItemsInput) => ReorderChangeLogItemsAction;
-declare const releaseNewVersion: () => ReleaseNewVersionAction;
-declare const baseActions: {
-  setName: (name: string | {
-    name: string;
-  }) => SetNameAction;
-  setPreferredEditor: (input: string | null | {
-    preferredEditor: string | null;
-  }) => SetPreferredEditorAction;
-  undo: (count?: number, scope?: string) => UndoAction;
-  redo: (count?: number, scope?: string) => RedoAction;
-  prune: (start?: number, end?: number, scope?: string) => SchemaPruneAction;
-  loadState: <TState extends PHBaseState = PHBaseState>(state: TState & {
-    name: string;
-  }, operations: number) => LoadStateAction;
-  noop: (scope?: string) => NOOPAction;
+type User = {
+  address: `0x${string}`;
+  networkId: string;
+  chainId: number;
+  ens?: ENSInfo;
+};
+type PartialRecord<K extends keyof any, T> = { [P in K]?: T };
+type RevisionsFilter = PartialRecord<string, number>;
+type GetDocumentOptions = ReducerOptions & {
+  revisions?: RevisionsFilter;
+  checkHashes?: boolean;
 };
-declare const documentModelActions: {
-  setModelName: (input: SetModelNameInput) => SetModelNameAction;
-  setModelId: (input: SetModelIdInput) => SetModelIdAction;
-  setModelExtension: (input: SetModelExtensionInput) => SetModelExtensionAction;
-  setModelDescription: (input: SetModelDescriptionInput) => SetModelDescriptionAction;
-  setAuthorName: (input: SetAuthorNameInput) => SetAuthorNameAction;
-  setAuthorWebsite: (input: SetAuthorWebsiteInput) => SetAuthorWebsiteAction;
-  addModule: (input: AddModuleInput) => AddModuleAction;
-  setModuleName: (input: SetModuleNameInput) => SetModuleNameAction;
-  setModuleDescription: (input: SetModuleDescriptionInput) => SetModuleDescriptionAction;
-  deleteModule: (input: DeleteModuleInput) => DeleteModuleAction;
-  reorderModules: (input: ReorderModulesInput) => ReorderModulesAction;
-  addOperation: (input: AddOperationInput) => AddOperationAction;
-  setOperationName: (input: SetOperationNameInput) => SetOperationNameAction;
-  setOperationScope: (input: SetOperationScopeInput) => SetOperationScopeAction;
-  setOperationSchema: (input: SetOperationSchemaInput) => SetOperationSchemaAction;
-  setOperationDescription: (input: SetOperationDescriptionInput) => SetOperationDescriptionAction;
-  setOperationTemplate: (input: SetOperationTemplateInput) => SetOperationTemplateAction;
-  setOperationReducer: (input: SetOperationReducerInput) => SetOperationReducerAction;
-  moveOperation: (input: MoveOperationInput) => MoveOperationAction;
-  deleteOperation: (input: DeleteOperationInput) => DeleteOperationAction;
-  reorderModuleOperations: (input: ReorderModuleOperationsInput) => ReorderModuleOperationsAction;
-  addOperationError: (input: AddOperationErrorInput) => AddOperationErrorAction;
-  setOperationErrorCode: (input: SetOperationErrorCodeInput) => SetOperationErrorCodeAction;
-  setOperationErrorName: (input: SetOperationErrorNameInput) => SetOperationErrorNameAction;
-  setOperationErrorDescription: (input: SetOperationErrorDescriptionInput) => SetOperationErrorDescriptionAction;
-  setOperationErrorTemplate: (input: SetOperationErrorTemplateInput) => SetOperationErrorTemplateAction;
-  deleteOperationError: (input: DeleteOperationErrorInput) => DeleteOperationErrorAction;
-  reorderOperationErrors: (input: ReorderOperationErrorsInput) => ReorderOperationErrorsAction;
-  addOperationExample: (input: AddOperationExampleInput) => AddOperationExampleAction;
-  updateOperationExample: (input: UpdateOperationExampleInput) => UpdateOperationExampleAction;
-  deleteOperationExample: (input: DeleteOperationExampleInput) => DeleteOperationExampleAction;
-  reorderOperationExamples: (input: ReorderOperationExamplesInput) => ReorderOperationExamplesAction;
-  setStateSchema: (input: SetStateSchemaInput) => SetStateSchemaAction;
-  setInitialState: (input: SetInitialStateInput) => SetInitialStateAction;
-  addStateExample: (input: AddStateExampleInput) => AddStateExampleAction;
-  updateStateExample: (input: UpdateStateExampleInput) => UpdateStateExampleAction;
-  deleteStateExample: (input: DeleteStateExampleInput) => DeleteStateExampleAction;
-  reorderStateExamples: (input: ReorderStateExamplesInput) => ReorderStateExamplesAction;
-  addChangeLogItem: (input: AddChangeLogItemInput) => AddChangeLogItemAction;
-  updateChangeLogItem: (input: UpdateChangeLogItemInput) => UpdateChangeLogItemAction;
-  deleteChangeLogItem: (input: DeleteChangeLogItemInput) => DeleteChangeLogItemAction;
-  reorderChangeLogItems: (input: ReorderChangeLogItemsInput) => ReorderChangeLogItemsAction;
-  releaseNewVersion: () => ReleaseNewVersionAction;
+type ActionErrorCallback = (error: unknown) => void;
+type EditorDispatch = (action: Action, onErrorCallback?: ActionErrorCallback) => void;
+type EditorProps = {
+  children?: ReactNode;
+  className?: string;
+  document?: PHDocument;
 };
-declare const actions: {
-  setModelName: (input: SetModelNameInput) => SetModelNameAction;
-  setModelId: (input: SetModelIdInput) => SetModelIdAction;
-  setModelExtension: (input: SetModelExtensionInput) => SetModelExtensionAction;
-  setModelDescription: (input: SetModelDescriptionInput) => SetModelDescriptionAction;
-  setAuthorName: (input: SetAuthorNameInput) => SetAuthorNameAction;
-  setAuthorWebsite: (input: SetAuthorWebsiteInput) => SetAuthorWebsiteAction;
-  addModule: (input: AddModuleInput) => AddModuleAction;
-  setModuleName: (input: SetModuleNameInput) => SetModuleNameAction;
-  setModuleDescription: (input: SetModuleDescriptionInput) => SetModuleDescriptionAction;
-  deleteModule: (input: DeleteModuleInput) => DeleteModuleAction;
-  reorderModules: (input: ReorderModulesInput) => ReorderModulesAction;
-  addOperation: (input: AddOperationInput) => AddOperationAction;
-  setOperationName: (input: SetOperationNameInput) => SetOperationNameAction;
-  setOperationScope: (input: SetOperationScopeInput) => SetOperationScopeAction;
-  setOperationSchema: (input: SetOperationSchemaInput) => SetOperationSchemaAction;
-  setOperationDescription: (input: SetOperationDescriptionInput) => SetOperationDescriptionAction;
-  setOperationTemplate: (input: SetOperationTemplateInput) => SetOperationTemplateAction;
-  setOperationReducer: (input: SetOperationReducerInput) => SetOperationReducerAction;
-  moveOperation: (input: MoveOperationInput) => MoveOperationAction;
-  deleteOperation: (input: DeleteOperationInput) => DeleteOperationAction;
-  reorderModuleOperations: (input: ReorderModuleOperationsInput) => ReorderModuleOperationsAction;
-  addOperationError: (input: AddOperationErrorInput) => AddOperationErrorAction;
-  setOperationErrorCode: (input: SetOperationErrorCodeInput) => SetOperationErrorCodeAction;
-  setOperationErrorName: (input: SetOperationErrorNameInput) => SetOperationErrorNameAction;
-  setOperationErrorDescription: (input: SetOperationErrorDescriptionInput) => SetOperationErrorDescriptionAction;
-  setOperationErrorTemplate: (input: SetOperationErrorTemplateInput) => SetOperationErrorTemplateAction;
-  deleteOperationError: (input: DeleteOperationErrorInput) => DeleteOperationErrorAction;
-  reorderOperationErrors: (input: ReorderOperationErrorsInput) => ReorderOperationErrorsAction;
-  addOperationExample: (input: AddOperationExampleInput) => AddOperationExampleAction;
-  updateOperationExample: (input: UpdateOperationExampleInput) => UpdateOperationExampleAction;
-  deleteOperationExample: (input: DeleteOperationExampleInput) => DeleteOperationExampleAction;
-  reorderOperationExamples: (input: ReorderOperationExamplesInput) => ReorderOperationExamplesAction;
-  setStateSchema: (input: SetStateSchemaInput) => SetStateSchemaAction;
-  setInitialState: (input: SetInitialStateInput) => SetInitialStateAction;
-  addStateExample: (input: AddStateExampleInput) => AddStateExampleAction;
-  updateStateExample: (input: UpdateStateExampleInput) => UpdateStateExampleAction;
-  deleteStateExample: (input: DeleteStateExampleInput) => DeleteStateExampleAction;
-  reorderStateExamples: (input: ReorderStateExamplesInput) => ReorderStateExamplesAction;
-  addChangeLogItem: (input: AddChangeLogItemInput) => AddChangeLogItemAction;
-  updateChangeLogItem: (input: UpdateChangeLogItemInput) => UpdateChangeLogItemAction;
-  deleteChangeLogItem: (input: DeleteChangeLogItemInput) => DeleteChangeLogItemAction;
-  reorderChangeLogItems: (input: ReorderChangeLogItemsInput) => ReorderChangeLogItemsAction;
-  releaseNewVersion: () => ReleaseNewVersionAction;
-  setName: (name: string | {
-    name: string;
-  }) => SetNameAction;
-  setPreferredEditor: (input: string | null | {
-    preferredEditor: string | null;
-  }) => SetPreferredEditorAction;
-  undo: (count?: number, scope?: string) => UndoAction;
-  redo: (count?: number, scope?: string) => RedoAction;
-  prune: (start?: number, end?: number, scope?: string) => SchemaPruneAction;
-  loadState: <TState extends PHBaseState = PHBaseState>(state: TState & {
+type SubgraphModule = {
+  id: string;
+  name: string;
+  gql: string;
+  endpoint: string;
+};
+type EditorModule<TProps = any> = {
+  Component: FC<EditorProps & TProps>;
+  documentTypes: string[];
+  config: {
+    id: string;
     name: string;
-  }, operations: number) => LoadStateAction;
-  noop: (scope?: string) => NOOPAction;
+  };
+};
+type ValidationError = {
+  message: string;
+  details: object;
+};
+type SkipHeaderOperations = Partial<Record<string, number>>;
+type ReplayDocumentOptions = {
+  checkHashes?: boolean;
+  reuseOperationResultingState?: boolean;
+  operationResultingStateParser?: <TState>(state: string) => TState;
+  skipIndexValidation?: boolean;
+};
+type OperationIndex = {
+  index: number;
+  skip: number;
+  id?: string;
+  timestampUtcMs?: string;
 };
 /**
- * The context of an action.
+ * Parameters used in a document signature.
  */
-type ActionContext = {
-  /** The index of the previous operation, showing intended ordering. */prevOpIndex?: number; /** The hash of the previous operation, showing intended state. */
-  prevOpHash?: string; /** A nonce, to cover specific signing attacks and to prevent replay attacks from no-ops. */
-  nonce?: string; /** The signer of the action. */
-  signer?: ActionSigner;
+type SigningParameters = {
+  documentType: string;
+  createdAtUtcIso: string;
+  /**
+   * The nonce can act as both a salt and a typical nonce.
+   */
+  nonce: string;
 };
 /**
- * Defines the basic structure of an action.
+ * Describes a signer that can sign both document headers and actions.
  */
-type Action = {
-  /** The id of the action. This is distinct from the operation id. */id: string; /** The name of the action. */
-  type: string; /** The timestamp of the action. */
-  timestampUtcMs: string; /** The payload of the action. */
-  input: unknown; /** The scope of the action */
-  scope: string;
+interface ISigner {
+  /** The user associated with the signer */
+  user?: UserActionSigner;
+  /** The app associated with the signer */
+  app?: AppActionSigner;
+  /** The corresponding public key */
+  publicKey: CryptoKey;
   /**
-   * The attachments included in the action.
+   * Signs raw data (used for document header signing).
    *
-   * This will be refactored in a future release.
+   * @param data - The data to sign.
+   * @returns The signature of the data.
    */
-  attachments?: AttachmentInput[]; /** The context of the action. */
-  context?: ActionContext;
+  sign: (data: Uint8Array) => Promise<Uint8Array>;
+  /**
+   * Verifies a signature.
+   *
+   * @param data - The data to verify.
+   * @param signature - The signature to verify.
+   */
+  verify: (data: Uint8Array, signature: Uint8Array) => Promise<void>;
+  /**
+   * Signs an action (used for operation signing).
+   *
+   * @param action - The action to sign.
+   * @param abortSignal - Optional abort signal to cancel the signing.
+   * @returns The signature tuple.
+   */
+  signAction: (action: Action, abortSignal?: AbortSignal) => Promise<Signature>;
+}
+type IsStateOfType<TState> = (state: unknown) => state is TState;
+type AssertIsStateOfType<TState> = (state: unknown) => asserts state is TState;
+type IsDocumentOfType<TState extends PHBaseState> = (document: unknown) => document is PHDocument<TState>;
+type AssertIsDocumentOfType<TState extends PHBaseState> = (document: unknown) => asserts document is PHDocument<TState>;
+type PartialState<TState> = TState | Partial<TState>;
+type CreateState<TState extends PHBaseState = PHBaseState> = (state?: PartialState<TState>) => TState;
+type SaveToFileHandle = (document: PHDocument, input: FileSystemFileHandle) => void | Promise<void>;
+type SaveToFile = (document: PHDocument, path: string, name?: string) => string | Promise<string>;
+type LoadFromInput<TState extends PHBaseState = PHBaseState> = (input: FileInput) => PHDocument<TState> | Promise<PHDocument<TState>>;
+type LoadFromFile<TState extends PHBaseState = PHBaseState> = (path: string) => PHDocument<TState> | Promise<PHDocument<TState>>;
+type CreateDocument<TState extends PHBaseState = PHBaseState> = (initialState?: Partial<TState>, createState?: CreateState<TState>) => PHDocument<TState>;
+type MinimalBackupData = {
+  documentId: string;
+  documentType: string;
+  branch: string;
+  state: PHBaseState;
+  name: string;
 };
-/**
- * The attributes stored for a file. Namely, attachments of a document.
- */
-type Attachment = {
-  /** The binary data of the attachment in Base64 */data: string; /** The MIME type of the attachment */
-  mimeType: string;
-  extension?: string | null;
-  fileName?: string | null;
+type DocumentModelUtils<TState extends PHBaseState = PHBaseState> = {
+  fileExtension: string;
+  createState: CreateState<TState>;
+  createDocument: CreateDocument<TState>;
+  loadFromInput: LoadFromInput<TState>;
+  saveToFileHandle: SaveToFileHandle;
+  isStateOfType: IsStateOfType<TState>;
+  assertIsStateOfType: AssertIsStateOfType<TState>;
+  isDocumentOfType: IsDocumentOfType<TState>;
+  assertIsDocumentOfType: AssertIsDocumentOfType<TState>;
 };
-type AttachmentInput = Attachment & {
-  hash: string;
+type Actions = Record<string, (...args: any[]) => Action>;
+type DocumentModelModule<TState extends PHBaseState = PHBaseState> = {
+  /** optional version field, should be made required */version?: number;
+  reducer: Reducer<TState>;
+  actions: Actions;
+  utils: DocumentModelUtils<TState>;
+  documentModel: DocumentModelPHState;
 };
-type ActionWithAttachment = Action & {
-  attachments: AttachmentInput[];
+type DocumentModelLib<TState extends PHBaseState = PHBaseState> = {
+  manifest: Manifest;
+  documentModels: readonly DocumentModelModule<TState>[];
+  editors: readonly EditorModule[];
+  subgraphs?: readonly SubgraphModule[];
+  upgradeManifests?: readonly UpgradeManifest<readonly number[]>[] | undefined;
+  processorFactory?: ProcessorFactoryBuilder;
 };
-/**
- * String type representing an attachment in a Document.
- *
- * @remarks
- * Attachment string is formatted as `attachment://<filename>`.
- */
-type AttachmentRef = string;
+type DocumentModelDocumentModelModule = DocumentModelModule<DocumentModelPHState>;
+type ConfigEntryType = z.infer<typeof ConfigEntryTypeSchema>;
+type ConfigEntry = z.infer<typeof ConfigEntrySchema>;
+type PowerhouseModule = z.infer<typeof PowerhouseModuleSchema>;
+type Publisher = z.infer<typeof PublisherSchema>;
+type Manifest = z.infer<typeof ManifestSchema>;
 //#endregion
-export { setName as $, ReorderOperationErrorsAction as $a, SetOperationReducerInputSchema as $c, MutationReorderOperationErrorsArgs as $i, ConfigEntryType as $n, SetOperationSchemaAction as $o, EditorDispatch as $r, DeleteChangeLogItemInputSchema as $s, skipHeaderOperations as $t, noop as A, OperationsByScope as Aa, ReorderModuleOperationsInputSchema as Ac, ModuleSpecification as Ai, RelationalDbProcessorClass as Al, ActionSignatureContext as An, SetModelNameAction as Ao, DocumentModelHeaderAction as Ar, UpdateOperationExampleAction as As, garbageCollect as At, reorderModules as B, RedoAction as Ba, SetModelExtensionInputSchema as Bc, MutationDeleteChangeLogItemInputArgs as Bi, ProcessorFilter as Bl, AddOperationErrorInput as Bn, SetOperationDescriptionInput as Bo, DocumentModelOperationErrorOperations as Br, UpgradeManifest as Bs, mapSkippedOperations as Bt, deleteOperation as C, MutationUpdateChangeLogItemInputArgs as Ca, PruneActionSchema as Cc, MakeEmpty as Ci, HashAlgorithms as Cl, defaultAuthState as Cn, SetInitialStateInput as Co, DeleteStateExampleInput as Cr, SubgraphModule as Cs, attachBranch as Ct, documentModelActions as D, OperationErrorSpecification as Da, RedoActionSchema as Dc, MappedOperation as Di, IRelationalQueryBuilder as Dl, defaultLocalState as Dn, SetModelExtensionInput as Do, DocumentModelDocument as Dr, UndoRedoAction as Ds, diffOperations as Dt, deleteStateExample as E, NOOPAction as Ea, RedoActionInputSchema as Ec, Manifest as Ei, IRelationalDbProcessor as El, defaultGlobalState as En, SetModelExtensionAction as Eo, DocumentModelAction as Er, UndoActionInput as Es, checkOperationsIntegrity as Et, prune as F, PruneAction as Fa, ScopeStateSchema as Fc, MutationAddModuleArgs as Fi, ProcessorApp as Fl, AddChangeLogItemInput as Fn, SetModuleNameInput as Fo, DocumentModelModule as Fr, UpdateStateExampleInput as Fs, hashDocumentStateForScope as Ft, setAuthorWebsite as G, RemoveRelationshipAction as Ga, SetNameActionInputSchema as Gc, MutationDeleteStateExampleArgs as Gi, DEFAULT_RELATIONAL_PROCESSOR_DB_NAME as Gl, AddRelationshipActionInput as Gn, SetOperationErrorNameAction as Go, DocumentModelStateAction as Gr, AddOperationErrorInputSchema as Gs, parseResultingState as Gt, reorderOperationExamples as H, Reducer as Ha, SetModelNameInputSchema as Hc, MutationDeleteOperationArgs as Hi, ProcessorStatus as Hl, AddOperationExampleInput as Hn, SetOperationErrorCodeInput as Ho, DocumentModelOperationExampleOperations as Hr, UpgradeTransition as Hs, merge as Ht, redo as I, PruneActionInput as Ia, SetAuthorNameInputSchema as Ic, MutationAddOperationArgs as Ii, ProcessorApps as Il, AddModuleAction as In, SetNameAction as Io, DocumentModelModuleAction as Ir, UpgradeDocumentAction as Is, isDocumentAction as It, setModelExtension as J, ReorderChangeLogItemsInput as Ja, SetOperationErrorCodeInputSchema as Jc, MutationPruneArgs as Ji, AppActionSigner as Jl, AssertIsDocumentOfType as Jn, SetOperationErrorTemplateInput as Jo, DocumentModelVersioningAction as Jr, AddStateExampleInputSchema as Js, readOnly as Jt, setInitialState as K, RemoveRelationshipActionInput as Ka, SetNameActionSchema as Kc, MutationLoadStateArgs as Ki, PROCESSOR_APPS as Kl, AddStateExampleAction as Kn, SetOperationErrorNameInput as Ko, DocumentModelStateOperations as Kr, AddOperationExampleInputSchema as Ks, precedes as Kt, releaseNewVersion as L, Publisher as La, SetAuthorWebsiteInputSchema as Lc, MutationAddOperationErrorArgs as Li, ProcessorDispatchResult as Ll, AddModuleInput as Ln, SetNameActionInput as Lo, DocumentModelModuleOperations as Lr, UpgradeDocumentActionInput as Ls, isNoopOperation as Lt, operationFromAction as M, PartialState as Ma, ReorderOperationErrorsInputSchema as Mc, MoveOperationInput as Mi, IProcessorDispatch as Ml, ActionVerificationHandler as Mn, SetModuleDescriptionAction as Mo, DocumentModelInput as Mr, UpdateRelationshipAction as Ms, garbageCollectV2 as Mt, operationFromOperation as N, PowerhouseModule as Na, ReorderOperationExamplesInputSchema as Nc, Mutation as Ni, IProcessorHostModule as Nl, Actions as Nn, SetModuleDescriptionInput as No, DocumentModelLib as Nr, UpdateRelationshipActionInput as Ns, getDocumentLastModified as Nt, loadState as O, OperationIndex as Oa, RedoSchema as Oc, Maybe as Oi, IRelationalQueryMethods as Ol, defaultPHState as On, SetModelIdAction as Oo, DocumentModelDocumentModelModule as Or, UpdateChangeLogItemAction as Os, filterDocumentOperationsResultingState as Ot, operationWithContext as P, Prune as Pa, ReorderStateExamplesInputSchema as Pc, MutationAddChangeLogItemInputArgs as Pi, IProcessorManager as Pl, AddChangeLogItemAction as Pn, SetModuleNameAction as Po, DocumentModelLocalState as Pr, UpdateStateExampleAction as Ps, groupOperationsByScope as Pt, setModuleName as Q, ReorderModulesInput as Qa, SetOperationNameInputSchema as Qc, MutationReorderModulesArgs as Qi, UserActionSigner as Ql, ConfigEntry as Qn, SetOperationReducerInput as Qo, ENSInfo as Qr, ConfigEntryTypeSchema as Qs, reshuffleByTimestampAndIndex as Qt, reorderChangeLogItems as R, Query as Ra, SetInitialStateInputSchema as Rc, MutationAddOperationExampleArgs as Ri, ProcessorFactory as Rl, AddOperationAction as Rn, SetNameOperation as Ro, DocumentModelOperationAction as Rr, User as Rs, isUndo as Rt, deleteModule as S, MutationUndoArgs as Sa, PruneActionInputSchema as Sc, Load_State as Si, ExtractProcessorSchemaOrSelf as Sl, createState as Sn, SetInitialStateAction as So, DeleteStateExampleAction as Sr, StateReducer as Ss, addUndo as St, deleteOperationExample as T, MutationUpdateStateExampleArgs as Ta, PublisherSchema as Tc, MakeOptional as Ti, IRelationalDb as Tl, defaultDocumentState as Tn, SetModelDescriptionInput as To, DocumentFile as Tr, UndoAction as Ts, checkCleanedOperationsIntegrity as Tt, reorderStateExamples as U, ReducerOptions as Ua, SetModuleDescriptionInputSchema as Uc, MutationDeleteOperationErrorArgs as Ui, TrackedProcessor as Ul, AddOperationInput as Un, SetOperationErrorDescriptionAction as Uo, DocumentModelOperationOperations as Ur, AddChangeLogItemInputSchema as Us, nextSkipNumber as Ut, reorderOperationErrors as V, RedoActionInput as Va, SetModelIdInputSchema as Vc, MutationDeleteModuleArgs as Vi, ProcessorRecord as Vl, AddOperationExampleAction as Vn, SetOperationErrorCodeAction as Vo, DocumentModelOperationExampleAction as Vr, UpgradeReducer as Vs, mapSkippedOperationsV2 as Vt, setAuthorName as W, ReleaseNewVersionAction as Wa, SetModuleNameInputSchema as Wc, MutationDeleteOperationExampleArgs as Wi, DEFAULT_ANALYTICS_PROCESSOR_DB_NAME as Wl, AddRelationshipAction as Wn, SetOperationErrorDescriptionInput as Wo, DocumentModelPHState as Wr, AddModuleInputSchema as Ws, operationsAreEqual as Wt, setModelName as X, ReorderModuleOperationsInput as Xa, SetOperationErrorNameInputSchema as Xc, MutationReorderChangeLogItemsInputArgs as Xi, PHDocumentSignatureInfo as Xl, Author as Xn, SetOperationNameInput as Xo, DocumentOperationsIgnoreMap as Xr, CodeExampleSchema as Xs, replayDocument as Xt, setModelId as Y, ReorderModuleOperationsAction as Ya, SetOperationErrorDescriptionInputSchema as Yc, MutationRedoArgs as Yi, HashConfig as Yl, AssertIsStateOfType as Yn, SetOperationNameAction as Yo, DocumentModelVersioningOperations as Yr, AuthorSchema as Ys, removeExistingOperations as Yt, setModuleDescription as Z, ReorderModulesAction as Za, SetOperationErrorTemplateInputSchema as Zc, MutationReorderModuleOperationsArgs as Zi, Signature as Zl, CodeExample as Zn, SetOperationReducerAction as Zo, DocumentSpecification as Zr, ConfigEntrySchema as Zs, reshuffleByTimestamp as Zt, baseActions as _, MutationSetOperationNameArgs as _a, OperationErrorSchema as _c, LoadFromFile as _i, createNamespacedDb as _l, createAuthState as _n, ScopeState as _o, DeleteOperationErrorAction as _r, SignatureVerificationHandler as _s, IntegrityIssueSubType as _t, AttachmentInput as a, MutationSetModelDescriptionArgs as aa, DocumentActionSchema as ac, GetDocumentOptions as ai, SetStateSchemaInputSchema as al, Operation as an, ReplayDocumentOptions as ao, CreateDocumentAction as ar, SetPreferredEditorAction as as, setOperationName as at, createAction as b, MutationSetOperationTemplateArgs as ba, PowerhouseModuleSchema as bc, LoadStateActionInput as bi, hashNamespace as bl, createGlobalState as bn, SetAuthorWebsiteAction as bo, DeleteOperationExampleInput as br, SkipHeaderOperations as bs, PHDocumentHeader as bt, actionFromAction as c, MutationSetModelNameArgs as ca, DocumentModelInputSchema as cc, IDocument as ci, StateSchema as cl, loadStateOperation as cn, SaveToFileHandle as co, DeleteChangeLogItemAction as cr, SetStateSchemaAction as cs, setOperationScope as ct, addChangeLogItem as d, MutationSetNameArgs as da, LoadStateActionSchema as dc, ISignalResult as di, UndoSchema as dl, setPreferredEditorOperation as dn, SchemaNOOPAction as do, DeleteChildDocumentSignal as dr, Set_PreferredEditor as ds, setStateSchema as dt, MutationReorderOperationExamplesArgs as ea, DeleteModuleInputSchema as ec, EditorModule as ei, SetOperationSchemaInputSchema as el, sortMappedOperations as en, ReorderOperationErrorsInput as eo, CopyChildDocumentInput as er, SetOperationSchemaInput as es, setOperationDescription as et, addModule as f, MutationSetOperationDescriptionArgs as fa, LoadStateActionStateInputSchema as fc, ISigner as fi, UpdateChangeLogItemInputSchema as fl, undoOperation as fn, SchemaPruneAction as fo, DeleteDocumentAction as fr, Signal as fs, undo as ft, addStateExample as g, MutationSetOperationErrorTemplateArgs as ga, MoveOperationInputSchema as gc, IsStateOfType as gi, isDefinedNonNullAny as gl, PHDocumentState as gn, SchemaUndoAction as go, DeleteOperationAction as gr, SignalType as gs, verifyOperationSignature as gt, addOperationExample as h, MutationSetOperationErrorNameArgs as ha, ModuleSchema as hc, IsDocumentOfType as hi, definedNonNullAnySchema as hl, PHBaseState as hn, SchemaSetPreferredEditorAction as ho, DeleteModuleInput as hr, SignalResults as hs, updateStateExample as ht, Attachment as i, MutationSetInitialStateArgs as ia, DeleteStateExampleInputSchema as ic, FileRegistry as ii, SetPreferredEditorActionSchema as il, DocumentOperations as in, ReorderStateExamplesInput as io, CreateDocument as ir, SetOperationTemplateInput as is, setOperationErrorTemplate as it, operationExampleCreators as j, PartialRecord as ja, ReorderModulesInputSchema as jc, MoveOperationAction as ji, IProcessor as jl, ActionSigningHandler as jn, SetModelNameInput as jo, DocumentModelHeaderOperations as jr, UpdateOperationExampleInput as js, garbageCollectDocumentOperations as jt, moveOperation as k, OperationSpecification as ka, ReorderChangeLogItemsInputSchema as kc, MinimalBackupData as ki, RelationalDbProcessor as kl, ActionErrorCallback as kn, SetModelIdInput as ko, DocumentModelGlobalState as kr, UpdateChangeLogItemInput as ks, filterDuplicatedOperations as kt, actionSigner as l, MutationSetModuleDescriptionArgs as la, DocumentSpecificationSchema as lc, IOperation as li, UndoActionInputSchema as ll, redoOperation as ln, Scalars as lo, DeleteChangeLogItemInput as lr, SetStateSchemaInput as ls, setOperationTemplate as lt, addOperationError as m, MutationSetOperationErrorDescriptionArgs as ma, ManifestSchema as mc, InputMaybe as mi, UpdateStateExampleInputSchema as ml, PHAuthState as mn, SchemaSetNameAction as mo, DeleteModuleAction as mr, SignalResult as ms, updateOperationExample as mt, ActionContext as n, MutationSetAuthorNameArgs as na, DeleteOperationExampleInputSchema as nc, Exact as ni, SetOperationTemplateInputSchema as nl, split as nn, ReorderOperationExamplesInput as no, CreateChildDocumentInput as nr, SetOperationScopeInput as ns, setOperationErrorDescription as nt, AttachmentRef as o, MutationSetModelExtensionArgs as oa, DocumentFileSchema as oc, IAction as oi, Set_NameSchema as ol, OperationContext as on, RevisionsFilter as oo, CreateDocumentActionInput as or, SetPreferredEditorActionInput as os, setOperationReducer as ot, addOperation as p, MutationSetOperationErrorCodeArgs as pa, Load_StateSchema as pc, Incremental as pi, UpdateOperationExampleInputSchema as pl, undoOperationV2 as pn, SchemaRedoAction as po, DeleteDocumentActionInput as pr, SignalDispatch as ps, updateChangeLogItem as pt, setModelDescription as q, ReorderChangeLogItemsAction as qa, SetOperationDescriptionInputSchema as qc, MutationMoveOperationArgs as qi, ActionSigner as ql, AddStateExampleInput as qn, SetOperationErrorTemplateAction as qo, DocumentModelUtils as qr, AddOperationInputSchema as qs, prepareOperations as qt, ActionWithAttachment as r, MutationSetAuthorWebsiteArgs as ra, DeleteOperationInputSchema as rc, FileInput as ri, SetPreferredEditorActionInputSchema as rl, updateHeaderRevision as rn, ReorderStateExamplesAction as ro, CreateChildDocumentSignal as rr, SetOperationTemplateAction as rs, setOperationErrorName as rt, actionContext as s, MutationSetModelIdArgs as sa, DocumentModelGlobalStateSchema as sc, ID as si, Set_PreferredEditorSchema as sl, OperationWithContext$1 as sn, SaveToFile as so, CreateState as sr, SetPreferredEditorOperation as ss, setOperationSchema as st, Action as t, MutationReorderStateExamplesArgs as ta, DeleteOperationErrorInputSchema as tc, EditorProps as ti, SetOperationScopeInputSchema as tl, sortOperations as tn, ReorderOperationExamplesAction as to, CopyChildDocumentSignal as tr, SetOperationScopeAction as ts, setOperationErrorCode as tt, actions as u, MutationSetModuleNameArgs as ua, LoadStateActionInputSchema as uc, ISignal as ui, UndoActionSchema as ul, setNameOperation as un, SchemaLoadStateAction as uo, DeleteChildDocumentInput as ur, Set_Name as us, setPreferredEditor as ut, buildOperationSignature as v, MutationSetOperationReducerArgs as va, OperationScopeSchema as vc, LoadFromInput as vi, createNamespacedQueryBuilder as vl, createBaseState as vn, SetAuthorNameAction as vo, DeleteOperationErrorInput as vr, SigningParameters as vs, IntegrityIssueType as vt, deleteOperationError as w, MutationUpdateOperationExampleArgs as wa, PruneSchema as wc, MakeMaybe as wi, IBaseRelationalDb as wl, defaultBaseState as wn, SetModelDescriptionAction as wo, DocumentAction as wr, Undo as ws, baseCreateDocument as wt, deleteChangeLogItem as x, MutationSetStateSchemaArgs as xa, PowerhouseModulesSchema as xc, LoadStateActionStateInput as xi, relationalDbToQueryBuilder as xl, createLocalState as xn, SetAuthorWebsiteInput as xo, DeleteOperationInput as xr, State as xs, PHDocumentMeta as xt, buildSignedAction as y, MutationSetOperationSchemaArgs as ya, OperationSpecificationSchema as yc, LoadStateAction as yi, createRelationalDb as yl, createDocumentState as yn, SetAuthorNameInput as yo, DeleteOperationExampleAction as yr, SkipHeaderOperationIndex as ys, PHDocument as yt, reorderModuleOperations as z, Redo as za, SetModelDescriptionInputSchema as zc, MutationAddStateExampleArgs as zi, ProcessorFactoryBuilder as zl, AddOperationErrorAction as zn, SetOperationDescriptionAction as zo, DocumentModelOperationErrorAction as zr, ValidationError as zs, isUndoRedo as zt };
-//# sourceMappingURL=actions-BqyQ1_K7.d.ts.map
+export { DocumentModelDocument as $, RedoActionSchema as $a, isUndo as $c, UndoRedoAction as $i, OperationErrorSpecification as $n, IRelationalQueryBuilder as $o, SetModelExtensionInput as $r, reorderChangeLogItems as $s, MappedOperation as $t, CreateDocument as A, DeleteStateExampleInputSchema as Aa, updateStateExample as Ac, SetOperationTemplateInput as Ai, PHBaseState as Al, MutationSetInitialStateArgs as An, SetPreferredEditorActionSchema as Ao, ReorderStateExamplesInput as Ar, addOperationExample as As, FileRegistry as At, DeleteModuleAction as B, ManifestSchema as Ba, checkCleanedOperationsIntegrity as Bc, SignalResult as Bi, defaultDocumentState as Bl, MutationSetOperationErrorDescriptionArgs as Bn, UpdateStateExampleInputSchema as Bo, SchemaSetNameAction as Br, deleteOperationExample as Bs, InputMaybe as Bt, CodeExample as C, ConfigEntrySchema as Ca, setOperationScope as Cc, SetOperationReducerAction as Ci, loadStateOperation as Cl, MutationReorderModuleOperationsArgs as Cn, SetOperationErrorTemplateInputSchema as Co, ReorderModulesAction as Cr, actionFromAction as Cs, DocumentSpecification as Ct, CopyChildDocumentSignal as D, DeleteOperationErrorInputSchema as Da, undo as Dc, SetOperationScopeAction as Di, undoOperation as Dl, MutationReorderStateExamplesArgs as Dn, SetOperationScopeInputSchema as Do, ReorderOperationExamplesAction as Dr, addModule as Ds, EditorProps as Dt, CopyChildDocumentInput as E, DeleteModuleInputSchema as Ea, setStateSchema as Ec, SetOperationSchemaInput as Ei, setPreferredEditorOperation as El, MutationReorderOperationExamplesArgs as En, SetOperationSchemaInputSchema as Eo, ReorderOperationErrorsInput as Er, addChangeLogItem as Es, EditorModule as Et, DeleteChangeLogItemInput as F, DocumentSpecificationSchema as Fa, PHDocumentHeader as Fc, SetStateSchemaInput as Fi, createGlobalState as Fl, MutationSetModuleDescriptionArgs as Fn, UndoActionInputSchema as Fo, Scalars as Fr, createAction as Fs, IOperation as Ft, DeleteOperationExampleAction as G, OperationSpecificationSchema as Ga, garbageCollect as Gc, SkipHeaderOperationIndex as Gi, AppActionSigner as Gl, MutationSetOperationSchemaArgs as Gn, createRelationalDb as Go, SetAuthorNameInput as Gr, noop as Gs, LoadStateAction as Gt, DeleteOperationAction as H, MoveOperationInputSchema as Ha, diffOperations as Hc, SignalType as Hi, defaultLocalState as Hl, MutationSetOperationErrorTemplateArgs as Hn, isDefinedNonNullAny as Ho, SchemaUndoAction as Hr, documentModelActions as Hs, IsStateOfType as Ht, DeleteChildDocumentInput as I, LoadStateActionInputSchema as Ia, PHDocumentMeta as Ic, Set_Name as Ii, createLocalState as Il, MutationSetModuleNameArgs as In, UndoActionSchema as Io, SchemaLoadStateAction as Ir, deleteChangeLogItem as Is, ISignal as It, DeleteStateExampleAction as J, PruneActionInputSchema as Ja, getDocumentLastModified as Jc, StateReducer as Ji, Signature as Jl, MutationUndoArgs as Jn, ExtractProcessorSchemaOrSelf as Jo, SetInitialStateAction as Jr, operationFromOperation as Js, Load_State as Jt, DeleteOperationExampleInput as K, PowerhouseModuleSchema as Ka, garbageCollectDocumentOperations as Kc, SkipHeaderOperations as Ki, HashConfig as Kl, MutationSetOperationTemplateArgs as Kn, hashNamespace as Ko, SetAuthorWebsiteAction as Kr, operationExampleCreators as Ks, LoadStateActionInput as Kt, DeleteChildDocumentSignal as L, LoadStateActionSchema as La, addUndo as Lc, Set_PreferredEditor as Li, createState as Ll, MutationSetNameArgs as Ln, UndoSchema as Lo, SchemaNOOPAction as Lr, deleteModule as Ls, ISignalResult as Lt, CreateDocumentActionInput as M, DocumentFileSchema as Ma, IntegrityIssueSubType as Mc, SetPreferredEditorActionInput as Mi, createAuthState as Ml, MutationSetModelExtensionArgs as Mn, Set_NameSchema as Mo, RevisionsFilter as Mr, baseActions as Ms, IAction as Mt, CreateState as N, DocumentModelGlobalStateSchema as Na, IntegrityIssueType as Nc, SetPreferredEditorOperation as Ni, createBaseState as Nl, MutationSetModelIdArgs as Nn, Set_PreferredEditorSchema as No, SaveToFile as Nr, buildOperationSignature as Ns, ID as Nt, CreateChildDocumentInput as O, DeleteOperationExampleInputSchema as Oa, updateChangeLogItem as Oc, SetOperationScopeInput as Oi, undoOperationV2 as Ol, MutationSetAuthorNameArgs as On, SetOperationTemplateInputSchema as Oo, ReorderOperationExamplesInput as Or, addOperation as Os, Exact as Ot, DeleteChangeLogItemAction as P, DocumentModelInputSchema as Pa, PHDocument as Pc, SetStateSchemaAction as Pi, createDocumentState as Pl, MutationSetModelNameArgs as Pn, StateSchema as Po, SaveToFileHandle as Pr, buildSignedAction as Ps, IDocument as Pt, DocumentModelAction as Q, RedoActionInputSchema as Qa, isNoopOperation as Qc, UndoActionInput as Qi, PROCESSOR_APPS as Ql, NOOPAction as Qn, IRelationalDbProcessor as Qo, SetModelExtensionAction as Qr, releaseNewVersion as Qs, Manifest as Qt, DeleteDocumentAction as R, LoadStateActionStateInputSchema as Ra, attachBranch as Rc, Signal as Ri, defaultAuthState as Rl, MutationSetOperationDescriptionArgs as Rn, UpdateChangeLogItemInputSchema as Ro, SchemaPruneAction as Rr, deleteOperation as Rs, ISigner as Rt, Author as S, CodeExampleSchema as Sa, setOperationSchema as Sc, SetOperationNameInput as Si, OperationWithContext$1 as Sl, MutationReorderChangeLogItemsInputArgs as Sn, SetOperationErrorNameInputSchema as So, ReorderModuleOperationsInput as Sr, actionContext as Ss, DocumentOperationsIgnoreMap as St, ConfigEntryType as T, DeleteChangeLogItemInputSchema as Ta, setPreferredEditor as Tc, SetOperationSchemaAction as Ti, setNameOperation as Tl, MutationReorderOperationErrorsArgs as Tn, SetOperationReducerInputSchema as To, ReorderOperationErrorsAction as Tr, actions as Ts, EditorDispatch as Tt, DeleteOperationErrorAction as U, OperationErrorSchema as Ua, filterDocumentOperationsResultingState as Uc, SignatureVerificationHandler as Ui, defaultPHState as Ul, MutationSetOperationNameArgs as Un, createNamespacedDb as Uo, ScopeState as Ur, loadState as Us, LoadFromFile as Ut, DeleteModuleInput as V, ModuleSchema as Va, checkOperationsIntegrity as Vc, SignalResults as Vi, defaultGlobalState as Vl, MutationSetOperationErrorNameArgs as Vn, definedNonNullAnySchema as Vo, SchemaSetPreferredEditorAction as Vr, deleteStateExample as Vs, IsDocumentOfType as Vt, DeleteOperationErrorInput as W, OperationScopeSchema as Wa, filterDuplicatedOperations as Wc, SigningParameters as Wi, ActionSigner as Wl, MutationSetOperationReducerArgs as Wn, createNamespacedQueryBuilder as Wo, SetAuthorNameAction as Wr, moveOperation as Ws, LoadFromInput as Wt, DocumentAction as X, PruneSchema as Xa, hashDocumentStateForScope as Xc, Undo as Xi, DEFAULT_ANALYTICS_PROCESSOR_DB_NAME as Xl, MutationUpdateOperationExampleArgs as Xn, IBaseRelationalDb as Xo, SetModelDescriptionAction as Xr, prune as Xs, MakeMaybe as Xt, DeleteStateExampleInput as Y, PruneActionSchema as Ya, groupOperationsByScope as Yc, SubgraphModule as Yi, UserActionSigner as Yl, MutationUpdateChangeLogItemInputArgs as Yn, HashAlgorithms as Yo, SetInitialStateInput as Yr, operationWithContext as Ys, MakeEmpty as Yt, DocumentFile as Z, PublisherSchema as Za, isDocumentAction as Zc, UndoAction as Zi, DEFAULT_RELATIONAL_PROCESSOR_DB_NAME as Zl, MutationUpdateStateExampleArgs as Zn, IRelationalDb as Zo, SetModelDescriptionInput as Zr, redo as Zs, MakeOptional as Zt, AddRelationshipActionInput as _, AddOperationErrorInputSchema as _a, setOperationErrorDescription as _c, SetOperationErrorNameAction as _i, split as _l, MutationDeleteStateExampleArgs as _n, SetNameActionInputSchema as _o, RemoveRelationshipAction as _r, ActionContext as _s, DocumentModelStateAction as _t, Actions as a, UpdateRelationshipActionInput as aa, setAuthorName as ac, SetModuleDescriptionInput as ai, operationsAreEqual as al, Mutation as an, ReorderOperationExamplesInputSchema as ao, PowerhouseModule as ar, IProcessorHostModule as as, DocumentModelLib as at, AssertIsDocumentOfType as b, AddStateExampleInputSchema as ba, setOperationName as bc, SetOperationErrorTemplateInput as bi, Operation as bl, MutationPruneArgs as bn, SetOperationErrorCodeInputSchema as bo, ReorderChangeLogItemsInput as br, AttachmentInput as bs, DocumentModelVersioningAction as bt, AddModuleAction as c, UpgradeDocumentAction as ca, setModelDescription as cc, SetNameAction as ci, prepareOperations as cl, MutationAddOperationArgs as cn, SetAuthorNameInputSchema as co, PruneActionInput as cr, ProcessorApps as cs, DocumentModelModuleAction as ct, AddOperationErrorAction as d, ValidationError as da, setModelName as dc, SetOperationDescriptionAction as di, replayDocument as dl, MutationAddStateExampleArgs as dn, SetModelDescriptionInputSchema as do, Redo as dr, ProcessorFactoryBuilder as ds, DocumentModelOperationErrorAction as dt, UpdateChangeLogItemAction as ea, reorderModuleOperations as ec, SetModelIdAction as ei, isUndoRedo as el, Maybe as en, RedoSchema as eo, OperationIndex as er, IRelationalQueryMethods as es, DocumentModelDocumentModelModule as et, AddOperationErrorInput as f, UpgradeManifest as fa, setModuleDescription as fc, SetOperationDescriptionInput as fi, reshuffleByTimestamp as fl, MutationDeleteChangeLogItemInputArgs as fn, SetModelExtensionInputSchema as fo, RedoAction as fr, ProcessorFilter as fs, DocumentModelOperationErrorOperations as ft, AddRelationshipAction as g, AddModuleInputSchema as ga, setOperationErrorCode as gc, SetOperationErrorDescriptionInput as gi, sortOperations as gl, MutationDeleteOperationExampleArgs as gn, SetModuleNameInputSchema as go, ReleaseNewVersionAction as gr, Action as gs, DocumentModelPHState as gt, AddOperationInput as h, AddChangeLogItemInputSchema as ha, setOperationDescription as hc, SetOperationErrorDescriptionAction as hi, sortMappedOperations as hl, MutationDeleteOperationErrorArgs as hn, SetModuleDescriptionInputSchema as ho, ReducerOptions as hr, TrackedProcessor as hs, DocumentModelOperationOperations as ht, ActionVerificationHandler as i, UpdateRelationshipAction as ia, reorderStateExamples as ic, SetModuleDescriptionAction as ii, nextSkipNumber as il, MoveOperationInput as in, ReorderOperationErrorsInputSchema as io, PartialState as ir, IProcessorDispatch as is, DocumentModelInput as it, CreateDocumentAction as j, DocumentActionSchema as ja, verifyOperationSignature as jc, SetPreferredEditorAction as ji, PHDocumentState as jl, MutationSetModelDescriptionArgs as jn, SetStateSchemaInputSchema as jo, ReplayDocumentOptions as jr, addStateExample as js, GetDocumentOptions as jt, CreateChildDocumentSignal as k, DeleteOperationInputSchema as ka, updateOperationExample as kc, SetOperationTemplateAction as ki, PHAuthState as kl, MutationSetAuthorWebsiteArgs as kn, SetPreferredEditorActionInputSchema as ko, ReorderStateExamplesAction as kr, addOperationError as ks, FileInput as kt, AddModuleInput as l, UpgradeDocumentActionInput as la, setModelExtension as lc, SetNameActionInput as li, readOnly as ll, MutationAddOperationErrorArgs as ln, SetAuthorWebsiteInputSchema as lo, Publisher as lr, ProcessorDispatchResult as ls, DocumentModelModuleOperations as lt, AddOperationExampleInput as m, UpgradeTransition as ma, setName as mc, SetOperationErrorCodeInput as mi, skipHeaderOperations as ml, MutationDeleteOperationArgs as mn, SetModelNameInputSchema as mo, Reducer as mr, ProcessorStatus as ms, DocumentModelOperationExampleOperations as mt, ActionSignatureContext as n, UpdateOperationExampleAction as na, reorderOperationErrors as nc, SetModelNameAction as ni, mapSkippedOperationsV2 as nl, ModuleSpecification as nn, ReorderModuleOperationsInputSchema as no, OperationsByScope as nr, RelationalDbProcessorClass as ns, DocumentModelHeaderAction as nt, AddChangeLogItemAction as o, UpdateStateExampleAction as oa, setAuthorWebsite as oc, SetModuleNameAction as oi, parseResultingState as ol, MutationAddChangeLogItemInputArgs as on, ReorderStateExamplesInputSchema as oo, Prune as or, IProcessorManager as os, DocumentModelLocalState as ot, AddOperationExampleAction as p, UpgradeReducer as pa, setModuleName as pc, SetOperationErrorCodeAction as pi, reshuffleByTimestampAndIndex as pl, MutationDeleteModuleArgs as pn, SetModelIdInputSchema as po, RedoActionInput as pr, ProcessorRecord as ps, DocumentModelOperationExampleAction as pt, DeleteOperationInput as q, PowerhouseModulesSchema as qa, garbageCollectV2 as qc, State as qi, PHDocumentSignatureInfo as ql, MutationSetStateSchemaArgs as qn, relationalDbToQueryBuilder as qo, SetAuthorWebsiteInput as qr, operationFromAction as qs, LoadStateActionStateInput as qt, ActionSigningHandler as r, UpdateOperationExampleInput as ra, reorderOperationExamples as rc, SetModelNameInput as ri, merge as rl, MoveOperationAction as rn, ReorderModulesInputSchema as ro, PartialRecord as rr, IProcessor as rs, DocumentModelHeaderOperations as rt, AddChangeLogItemInput as s, UpdateStateExampleInput as sa, setInitialState as sc, SetModuleNameInput as si, precedes as sl, MutationAddModuleArgs as sn, ScopeStateSchema as so, PruneAction as sr, ProcessorApp as ss, DocumentModelModule as st, ActionErrorCallback as t, UpdateChangeLogItemInput as ta, reorderModules as tc, SetModelIdInput as ti, mapSkippedOperations as tl, MinimalBackupData as tn, ReorderChangeLogItemsInputSchema as to, OperationSpecification as tr, RelationalDbProcessor as ts, DocumentModelGlobalState as tt, AddOperationAction as u, User as ua, setModelId as uc, SetNameOperation as ui, removeExistingOperations as ul, MutationAddOperationExampleArgs as un, SetInitialStateInputSchema as uo, Query as ur, ProcessorFactory as us, DocumentModelOperationAction as ut, AddStateExampleAction as v, AddOperationExampleInputSchema as va, setOperationErrorName as vc, SetOperationErrorNameInput as vi, updateHeaderRevision as vl, MutationLoadStateArgs as vn, SetNameActionSchema as vo, RemoveRelationshipActionInput as vr, ActionWithAttachment as vs, DocumentModelStateOperations as vt, ConfigEntry as w, ConfigEntryTypeSchema as wa, setOperationTemplate as wc, SetOperationReducerInput as wi, redoOperation as wl, MutationReorderModulesArgs as wn, SetOperationNameInputSchema as wo, ReorderModulesInput as wr, actionSigner as ws, ENSInfo as wt, AssertIsStateOfType as x, AuthorSchema as xa, setOperationReducer as xc, SetOperationNameAction as xi, OperationContext as xl, MutationRedoArgs as xn, SetOperationErrorDescriptionInputSchema as xo, ReorderModuleOperationsAction as xr, AttachmentRef as xs, DocumentModelVersioningOperations as xt, AddStateExampleInput as y, AddOperationInputSchema as ya, setOperationErrorTemplate as yc, SetOperationErrorTemplateAction as yi, DocumentOperations as yl, MutationMoveOperationArgs as yn, SetOperationDescriptionInputSchema as yo, ReorderChangeLogItemsAction as yr, Attachment as ys, DocumentModelUtils as yt, DeleteDocumentActionInput as z, Load_StateSchema as za, baseCreateDocument as zc, SignalDispatch as zi, defaultBaseState as zl, MutationSetOperationErrorCodeArgs as zn, UpdateOperationExampleInputSchema as zo, SchemaRedoAction as zr, deleteOperationError as zs, Incremental as zt };
+//# sourceMappingURL=types-CC6ib3_2.d.ts.map