@powerhousedao/shared 6.2.0-dev.4 → 6.2.0-dev.41

package/dist/types-Bo4Rb8Yf.d.ts

@@ -0,0 +1,2492 @@
+import { f as IAnalyticsStore } from "./types-C1in4fl3.js";
+import { z } from "zod";
+import { Draft } from "mutative";
+import { OperationWithContext } from "@powerhousedao/shared/document-model";
+import { Kysely, QueryCreator } from "kysely";
+import { FC, ReactNode } from "react";
+
+//#region processors/constants.d.ts
+declare const PROCESSOR_APPS: readonly ["connect", "switchboard"];
+declare const DEFAULT_RELATIONAL_PROCESSOR_DB_NAME = "relational-db";
+declare const DEFAULT_ANALYTICS_PROCESSOR_DB_NAME = "analytics-db";
+//#endregion
+//#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 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;
+};
+/**
+ * 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 - Deprecated and ignored. Retained so action creators
+ *   generated before the attachment-system removal keep their 5-argument shape.
+ * @param validator - The validator to use for the input properties.
+ * @param scope - The scope of the action, can either be 'global' or 'local'.
+ *
+ * @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?: unknown, 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 context of the action. */
+  context?: ActionContext;
+};
+//#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
+//#region document-model/schemas.d.ts
+type definedNonNullAny = {};
+declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
+declare const definedNonNullAnySchema: z.ZodAny & z.ZodType<definedNonNullAny, any, z.core.$ZodTypeInternals<definedNonNullAny, any>>;
+declare const Load_StateSchema: z.ZodEnum<{
+  LOAD_STATE: "LOAD_STATE";
+}>;
+declare const PruneSchema: z.ZodEnum<{
+  PRUNE: "PRUNE";
+}>;
+declare const RedoSchema: z.ZodEnum<{
+  REDO: "REDO";
+}>;
+declare const Set_NameSchema: z.ZodEnum<{
+  SET_NAME: "SET_NAME";
+}>;
+declare const Set_PreferredEditorSchema: z.ZodEnum<{
+  SET_PREFERRED_EDITOR: "SET_PREFERRED_EDITOR";
+}>;
+declare const UndoSchema: z.ZodEnum<{
+  UNDO: "UNDO";
+}>;
+declare function OperationScopeSchema(): z.ZodString;
+declare function DocumentActionSchema(): z.ZodUnion<readonly [z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  timestampUtcMs: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  input: z.ZodType<LoadStateActionInput, LoadStateActionInput, z.core.$ZodTypeInternals<LoadStateActionInput, LoadStateActionInput>>;
+  type: z.ZodType<"LOAD_STATE", "LOAD_STATE", z.core.$ZodTypeInternals<"LOAD_STATE", "LOAD_STATE">>;
+  scope: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  timestampUtcMs: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  input: z.ZodType<PruneActionInput, PruneActionInput, z.core.$ZodTypeInternals<PruneActionInput, PruneActionInput>>;
+  type: z.ZodType<"PRUNE", "PRUNE", z.core.$ZodTypeInternals<"PRUNE", "PRUNE">>;
+  scope: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  timestampUtcMs: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  input: z.ZodType<RedoActionInput, RedoActionInput, z.core.$ZodTypeInternals<RedoActionInput, RedoActionInput>>;
+  type: z.ZodType<"REDO", "REDO", z.core.$ZodTypeInternals<"REDO", "REDO">>;
+  scope: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  timestampUtcMs: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  input: z.ZodType<SetNameActionInput, SetNameActionInput, z.core.$ZodTypeInternals<SetNameActionInput, SetNameActionInput>>;
+  type: z.ZodType<"SET_NAME", "SET_NAME", z.core.$ZodTypeInternals<"SET_NAME", "SET_NAME">>;
+  scope: z.ZodType<"global", "global", z.core.$ZodTypeInternals<"global", "global">>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  timestampUtcMs: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  input: z.ZodType<SetPreferredEditorActionInput, SetPreferredEditorActionInput, z.core.$ZodTypeInternals<SetPreferredEditorActionInput, SetPreferredEditorActionInput>>;
+  type: z.ZodType<"SET_PREFERRED_EDITOR", "SET_PREFERRED_EDITOR", z.core.$ZodTypeInternals<"SET_PREFERRED_EDITOR", "SET_PREFERRED_EDITOR">>;
+  scope: z.ZodType<"header", "header", z.core.$ZodTypeInternals<"header", "header">>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  timestampUtcMs: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  input: z.ZodType<UndoActionInput, UndoActionInput, z.core.$ZodTypeInternals<UndoActionInput, UndoActionInput>>;
+  type: z.ZodType<"UNDO", "UNDO", z.core.$ZodTypeInternals<"UNDO", "UNDO">>;
+  scope: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>]>;
+declare function LoadStateActionSchema(): z.ZodObject<Properties<SchemaLoadStateAction>>;
+declare function LoadStateActionInputSchema(): z.ZodObject<Properties<LoadStateActionInput>>;
+declare function LoadStateActionStateInputSchema(): z.ZodObject<Properties<LoadStateActionStateInput>>;
+declare function PruneActionSchema(): z.ZodObject<Properties<SchemaPruneAction>>;
+declare function PruneActionInputSchema(): z.ZodObject<Properties<PruneActionInput>>;
+declare function RedoActionInputSchema(): z.ZodObject<{
+  count: z.ZodNumber;
+}, z.core.$strip>;
+declare function RedoActionSchema(): z.ZodObject<Properties<SchemaRedoAction>>;
+declare function SetNameActionInputSchema(): z.ZodObject<{
+  name: z.ZodString;
+}, z.core.$strip>;
+declare function SetNameActionSchema(): z.ZodObject<Properties<SchemaSetNameAction>>;
+declare function SetPreferredEditorActionInputSchema(): z.ZodObject<{
+  preferredEditor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare function SetPreferredEditorActionSchema(): z.ZodObject<Properties<SchemaSetPreferredEditorAction>>;
+declare function UndoActionInputSchema(): z.ZodObject<{
+  count: z.ZodNumber;
+}, z.core.$strip>;
+declare function UndoActionSchema(): z.ZodObject<Properties<SchemaUndoAction>>;
+type Properties<T> = Required<{ [K in keyof T]: z.ZodType<T[K], T[K]> }>;
+declare function AddChangeLogItemInputSchema(): z.ZodObject<Properties<AddChangeLogItemInput>>;
+declare function AddModuleInputSchema(): z.ZodObject<Properties<AddModuleInput>>;
+declare function AddOperationErrorInputSchema(): z.ZodObject<Properties<AddOperationErrorInput>>;
+declare function AddOperationExampleInputSchema(): z.ZodObject<Properties<AddOperationExampleInput>>;
+declare function AddOperationInputSchema(): z.ZodObject<Properties<AddOperationInput>>;
+declare function AddStateExampleInputSchema(): z.ZodObject<Properties<AddStateExampleInput>>;
+declare function AuthorSchema(): z.ZodObject<Properties<Author>>;
+declare function CodeExampleSchema(): z.ZodObject<Properties<CodeExample>>;
+declare function DeleteChangeLogItemInputSchema(): z.ZodObject<Properties<DeleteChangeLogItemInput>>;
+declare function DeleteModuleInputSchema(): z.ZodObject<Properties<DeleteModuleInput>>;
+declare function DeleteOperationErrorInputSchema(): z.ZodObject<Properties<DeleteOperationErrorInput>>;
+declare function DeleteOperationExampleInputSchema(): z.ZodObject<Properties<DeleteOperationExampleInput>>;
+declare function DeleteOperationInputSchema(): z.ZodObject<Properties<DeleteOperationInput>>;
+declare function DeleteStateExampleInputSchema(): z.ZodObject<Properties<DeleteStateExampleInput>>;
+declare function DocumentModelInputSchema(): z.ZodUnion<readonly [z.ZodObject<Required<{
+  __typename?: z.ZodType<"AddChangeLogItemInput" | undefined, "AddChangeLogItemInput" | undefined, z.core.$ZodTypeInternals<"AddChangeLogItemInput" | undefined, "AddChangeLogItemInput" | undefined>> | undefined;
+  content: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  insertBefore: z.ZodType<Maybe<string>, Maybe<string>, z.core.$ZodTypeInternals<Maybe<string>, Maybe<string>>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  description?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  name: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  errorCode?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  errorDescription?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  errorName?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  errorTemplate?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  operationId: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  example: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  operationId: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  description?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  moduleId: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  name: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  reducer?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  schema?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  template?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  scope?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  scope: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  example: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  insertBefore?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  __typename?: z.ZodType<"DeleteChangeLogItemInput" | undefined, "DeleteChangeLogItemInput" | undefined, z.core.$ZodTypeInternals<"DeleteChangeLogItemInput" | undefined, "DeleteChangeLogItemInput" | undefined>> | undefined;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  scope: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  newModuleId: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  operationId: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  __typename?: z.ZodType<"ReorderChangeLogItemsInput" | undefined, "ReorderChangeLogItemsInput" | undefined, z.core.$ZodTypeInternals<"ReorderChangeLogItemsInput" | undefined, "ReorderChangeLogItemsInput" | undefined>> | undefined;
+  order: z.ZodType<string[], string[], z.core.$ZodTypeInternals<string[], string[]>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  moduleId: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  order: z.ZodType<string[], string[], z.core.$ZodTypeInternals<string[], string[]>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  order: z.ZodType<string[], string[], z.core.$ZodTypeInternals<string[], string[]>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  operationId: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  order: z.ZodType<string[], string[], z.core.$ZodTypeInternals<string[], string[]>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  operationId: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  order: z.ZodType<string[], string[], z.core.$ZodTypeInternals<string[], string[]>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  scope: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  order: z.ZodType<string[], string[], z.core.$ZodTypeInternals<string[], string[]>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  authorName: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  authorWebsite: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  scope: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  initialValue: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  description: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  extension: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  name: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  description?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  name?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  description?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  errorCode?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  errorDescription?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  errorName?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  errorTemplate?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  name?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  reducer?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  schema?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  template?: z.ZodType<InputMaybe<string>, InputMaybe<string>, z.core.$ZodTypeInternals<InputMaybe<string>, InputMaybe<string>>> | undefined;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  scope: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  schema: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  __typename?: z.ZodType<"UpdateChangeLogItemInput" | undefined, "UpdateChangeLogItemInput" | undefined, z.core.$ZodTypeInternals<"UpdateChangeLogItemInput" | undefined, "UpdateChangeLogItemInput" | undefined>> | undefined;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  newContent: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  example: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>, z.ZodObject<Required<{
+  scope: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+  newExample: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}>, z.core.$strip>]>;
+declare function DocumentModelGlobalStateSchema(): z.ZodObject<Properties<DocumentModelGlobalState>>;
+declare function DocumentSpecificationSchema(): z.ZodObject<Properties<DocumentSpecification>>;
+declare function ModuleSchema(): z.ZodObject<Properties<ModuleSpecification>>;
+declare function MoveOperationInputSchema(): z.ZodObject<Properties<MoveOperationInput>>;
+declare function OperationSpecificationSchema(): z.ZodObject<Properties<OperationSpecification>>;
+declare function OperationErrorSchema(): z.ZodObject<Properties<OperationErrorSpecification>>;
+declare function ReorderChangeLogItemsInputSchema(): z.ZodObject<Properties<ReorderChangeLogItemsInput>>;
+declare function ReorderModuleOperationsInputSchema(): z.ZodObject<Properties<ReorderModuleOperationsInput>>;
+declare function ReorderModulesInputSchema(): z.ZodObject<Properties<ReorderModulesInput>>;
+declare function ReorderOperationErrorsInputSchema(): z.ZodObject<Properties<ReorderOperationErrorsInput>>;
+declare function ReorderOperationExamplesInputSchema(): z.ZodObject<Properties<ReorderOperationExamplesInput>>;
+declare function ReorderStateExamplesInputSchema(): z.ZodObject<Properties<ReorderStateExamplesInput>>;
+declare function SetAuthorNameInputSchema(): z.ZodObject<Properties<SetAuthorNameInput>>;
+declare function SetAuthorWebsiteInputSchema(): z.ZodObject<Properties<SetAuthorWebsiteInput>>;
+declare function SetInitialStateInputSchema(): z.ZodObject<Properties<SetInitialStateInput>>;
+declare function SetModelDescriptionInputSchema(): z.ZodObject<Properties<SetModelDescriptionInput>>;
+declare function SetModelExtensionInputSchema(): z.ZodObject<Properties<SetModelExtensionInput>>;
+declare function SetModelIdInputSchema(): z.ZodObject<Properties<SetModelIdInput>>;
+declare function SetModelNameInputSchema(): z.ZodObject<Properties<SetModelNameInput>>;
+declare function SetModuleDescriptionInputSchema(): z.ZodObject<Properties<SetModuleDescriptionInput>>;
+declare function SetModuleNameInputSchema(): z.ZodObject<Properties<SetModuleNameInput>>;
+declare function SetOperationDescriptionInputSchema(): z.ZodObject<Properties<SetOperationDescriptionInput>>;
+declare function SetOperationErrorCodeInputSchema(): z.ZodObject<Properties<SetOperationErrorCodeInput>>;
+declare function SetOperationErrorDescriptionInputSchema(): z.ZodObject<Properties<SetOperationErrorDescriptionInput>>;
+declare function SetOperationErrorNameInputSchema(): z.ZodObject<Properties<SetOperationErrorNameInput>>;
+declare function SetOperationErrorTemplateInputSchema(): z.ZodObject<Properties<SetOperationErrorTemplateInput>>;
+declare function SetOperationNameInputSchema(): z.ZodObject<Properties<SetOperationNameInput>>;
+declare function SetOperationScopeInputSchema(): z.ZodObject<Properties<SetOperationScopeInput>>;
+declare function SetOperationReducerInputSchema(): z.ZodObject<Properties<SetOperationReducerInput>>;
+declare function SetOperationSchemaInputSchema(): z.ZodObject<Properties<SetOperationSchemaInput>>;
+declare function SetOperationTemplateInputSchema(): z.ZodObject<Properties<SetOperationTemplateInput>>;
+declare function SetStateSchemaInputSchema(): z.ZodObject<Properties<SetStateSchemaInput>>;
+declare function StateSchema(): z.ZodObject<Properties<State>>;
+declare function ScopeStateSchema(): z.ZodObject<Properties<ScopeState>>;
+declare function UpdateChangeLogItemInputSchema(): z.ZodObject<Properties<UpdateChangeLogItemInput>>;
+declare function UpdateOperationExampleInputSchema(): z.ZodObject<Properties<UpdateOperationExampleInput>>;
+declare function UpdateStateExampleInputSchema(): z.ZodObject<Properties<UpdateStateExampleInput>>;
+declare const PowerhouseModuleSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  documentTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const PowerhouseModulesSchema: z.ZodOptional<z.ZodArray<z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  documentTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>>;
+declare const PublisherSchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const ConfigEntryTypeSchema: z.ZodUnion<readonly [z.ZodLiteral<"var">, z.ZodLiteral<"secret">]>;
+declare const ConfigEntrySchema: z.ZodObject<{
+  name: z.ZodString;
+  type: z.ZodUnion<readonly [z.ZodLiteral<"var">, z.ZodLiteral<"secret">]>;
+  description: z.ZodOptional<z.ZodString>;
+  required: z.ZodOptional<z.ZodBoolean>;
+  default: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const ManifestSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  category: z.ZodOptional<z.ZodString>;
+  publisher: z.ZodOptional<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  documentModels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    documentTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>>;
+  apps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    documentTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>>;
+  editors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    documentTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>>;
+  processors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    documentTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>>;
+  subgraphs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    documentTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>>;
+  config: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodUnion<readonly [z.ZodLiteral<"var">, z.ZodLiteral<"secret">]>;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+//#endregion
+//#region document-model/upgrades.d.ts
+/** Upgrade reducer transforms a document from one version to another */
+type UpgradeReducer<TFrom extends PHBaseState, TTo extends PHBaseState> = (document: PHDocument<TFrom>, action: Action) => PHDocument<TTo>;
+type ModelVersion = number;
+/** Metadata about a version transition */
+type UpgradeTransition = {
+  toVersion: ModelVersion;
+  upgradeReducer: UpgradeReducer<any, any>;
+  description?: string;
+};
+type TupleMember<T extends readonly unknown[]> = T[number];
+/** Manifest declaring all supported versions and upgrade paths */
+type UpgradeManifest<TVersions extends readonly number[]> = {
+  documentType: string;
+  latestVersion: TupleMember<TVersions>;
+  supportedVersions: TVersions;
+  upgrades: { [V in Exclude<TupleMember<TVersions>, 1> as `v${V}`]: UpgradeTransition };
+};
+/**
+ * Applies an UPGRADE_DOCUMENT action to a document.
+ * Handles all upgrade scenarios including initial upgrades, no-ops, and multi-step upgrades.
+ *
+ * Behavior based on fromVersion/toVersion:
+ * - fromVersion === toVersion (and fromVersion > 0): No-op - return unchanged document
+ * - fromVersion > toVersion: Throw DowngradeNotSupportedError
+ * - All other cases: Apply upgradePath transitions (if provided), then apply initialState, set version
+ */
+declare function applyUpgradeDocumentAction(document: PHDocument, action: UpgradeDocumentAction, upgradePath?: UpgradeTransition[]): PHDocument;
+/**
+ * Applies a DELETE_DOCUMENT action to a document.
+ * Marks the document as deleted in the document scope state.
+ */
+declare function applyDeleteDocumentAction(document: PHDocument, action: DeleteDocumentAction): PHDocument;
+/**
+ * Computes the ordered list of upgrade transitions needed to move from
+ * fromVersion to toVersion using the provided manifest.
+ * Walks keys v(fromVersion+1)..v(toVersion) and throws a descriptive Error
+ * if the manifest is absent or any step is missing.
+ */
+declare function computeUpgradeTransitions(manifest: UpgradeManifest<readonly number[]> | undefined, fromVersion: number, toVersion: number): UpgradeTransition[];
+//#endregion
+//#region document-model/types.d.ts
+type State = {
+  examples: CodeExample[];
+  initialValue: string;
+  schema: string;
+};
+type ScopeState = {
+  global: State;
+  local: State;
+};
+type Author = {
+  name: string;
+  website: string | null;
+};
+type OperationErrorSpecification = {
+  code: string | null;
+  description: string | null;
+  id: ID;
+  name: string | null;
+  template: string | null;
+};
+type CodeExample = {
+  id: ID;
+  value: string;
+};
+type OperationSpecification = {
+  description: string | null;
+  errors: OperationErrorSpecification[];
+  examples: CodeExample[];
+  id: ID;
+  name: string | null;
+  reducer: string | null;
+  schema: string | null;
+  template: string | null;
+  scope: string;
+};
+type ModuleSpecification = {
+  description: string | null;
+  id: ID;
+  name: string;
+  operations: OperationSpecification[];
+};
+type DocumentSpecification = {
+  changeLog: string[];
+  modules: ModuleSpecification[];
+  state: ScopeState;
+  version: number;
+};
+type DocumentModelGlobalState = {
+  author: Author;
+  description: string;
+  extension: string;
+  id: string;
+  name: string;
+  specifications: DocumentSpecification[];
+};
+type DocumentModelLocalState = {};
+type DocumentModelPHState = PHBaseState & {
+  global: DocumentModelGlobalState;
+  local: DocumentModelLocalState;
+};
+type DocumentModelDocument = PHDocument<DocumentModelPHState>;
+type DocumentModelAction = DocumentModelHeaderAction | DocumentModelVersioningAction | DocumentModelModuleAction | DocumentModelOperationErrorAction | DocumentModelOperationExampleAction | DocumentModelOperationAction | DocumentModelStateAction;
+type AddChangeLogItemInput = {
+  __typename?: "AddChangeLogItemInput";
+  content: Scalars["String"]["output"];
+  id: Scalars["ID"]["output"];
+  insertBefore: Maybe<Scalars["ID"]["output"]>;
+};
+type AddModuleInput = {
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  id: Scalars["ID"]["input"];
+  name: Scalars["String"]["input"];
+};
+type AddOperationErrorInput = {
+  errorCode?: InputMaybe<Scalars["String"]["input"]>;
+  errorDescription?: InputMaybe<Scalars["String"]["input"]>;
+  errorName?: InputMaybe<Scalars["String"]["input"]>;
+  errorTemplate?: InputMaybe<Scalars["String"]["input"]>;
+  id: Scalars["ID"]["input"];
+  operationId: Scalars["ID"]["input"];
+};
+type AddOperationExampleInput = {
+  example: Scalars["String"]["input"];
+  id: Scalars["ID"]["input"];
+  operationId: Scalars["ID"]["input"];
+};
+type AddOperationInput = {
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  id: Scalars["ID"]["input"];
+  moduleId: Scalars["ID"]["input"];
+  name: Scalars["String"]["input"];
+  reducer?: InputMaybe<Scalars["String"]["input"]>;
+  schema?: InputMaybe<Scalars["String"]["input"]>;
+  template?: InputMaybe<Scalars["String"]["input"]>;
+  scope?: InputMaybe<string>;
+};
+type AddStateExampleInput = {
+  scope: Scalars["String"]["input"];
+  example: Scalars["String"]["input"];
+  id: Scalars["ID"]["input"];
+  insertBefore?: InputMaybe<Scalars["ID"]["input"]>;
+};
+type DeleteChangeLogItemInput = {
+  __typename?: "DeleteChangeLogItemInput";
+  id: Scalars["ID"]["output"];
+};
+type DeleteModuleInput = {
+  id: Scalars["ID"]["input"];
+};
+type DeleteOperationErrorInput = {
+  id: Scalars["ID"]["input"];
+};
+type DeleteOperationExampleInput = {
+  id: Scalars["ID"]["input"];
+};
+type DeleteOperationInput = {
+  id: Scalars["ID"]["input"];
+};
+type DeleteStateExampleInput = {
+  scope: Scalars["String"]["input"];
+  id: Scalars["ID"]["input"];
+};
+type DocumentModelInput = AddChangeLogItemInput | AddModuleInput | AddOperationErrorInput | AddOperationExampleInput | AddOperationInput | AddStateExampleInput | DeleteChangeLogItemInput | DeleteModuleInput | DeleteOperationErrorInput | DeleteOperationExampleInput | DeleteOperationInput | DeleteStateExampleInput | MoveOperationInput | ReorderChangeLogItemsInput | ReorderModuleOperationsInput | ReorderModulesInput | ReorderOperationErrorsInput | ReorderOperationExamplesInput | ReorderStateExamplesInput | SetAuthorNameInput | SetAuthorWebsiteInput | SetInitialStateInput | SetModelDescriptionInput | SetModelExtensionInput | SetModelIdInput | SetModelNameInput | SetModuleDescriptionInput | SetModuleNameInput | SetOperationDescriptionInput | SetOperationErrorCodeInput | SetOperationErrorDescriptionInput | SetOperationErrorNameInput | SetOperationErrorTemplateInput | SetOperationNameInput | SetOperationReducerInput | SetOperationSchemaInput | SetOperationTemplateInput | SetStateSchemaInput | UpdateChangeLogItemInput | UpdateOperationExampleInput | UpdateStateExampleInput;
+type MoveOperationInput = {
+  newModuleId: Scalars["ID"]["input"];
+  operationId: Scalars["ID"]["input"];
+};
+type Mutation = {
+  __typename?: "Mutation";
+  addChangeLogItemInput: DocumentModelGlobalState;
+  addModule: DocumentModelGlobalState;
+  addOperation: DocumentModelGlobalState;
+  addOperationError: DocumentModelGlobalState;
+  addOperationExample: DocumentModelGlobalState;
+  addStateExample: DocumentModelGlobalState;
+  deleteChangeLogItemInput: DocumentModelGlobalState;
+  deleteModule: DocumentModelGlobalState;
+  deleteOperation: DocumentModelGlobalState;
+  deleteOperationError: DocumentModelGlobalState;
+  deleteOperationExample: DocumentModelGlobalState;
+  deleteStateExample: DocumentModelGlobalState;
+  moveOperation: DocumentModelGlobalState;
+  releaseNewVersion: DocumentModelGlobalState;
+  reorderChangeLogItemsInput: DocumentModelGlobalState;
+  reorderModuleOperations: DocumentModelGlobalState;
+  reorderModules: DocumentModelGlobalState;
+  reorderOperationErrors: DocumentModelGlobalState;
+  reorderOperationExamples: DocumentModelGlobalState;
+  reorderStateExamples: DocumentModelGlobalState;
+  setAuthorName: DocumentModelGlobalState;
+  setAuthorWebsite: DocumentModelGlobalState;
+  setInitialState: DocumentModelGlobalState;
+  setModelDescription: DocumentModelGlobalState;
+  setModelExtension: DocumentModelGlobalState;
+  setModelId: DocumentModelGlobalState;
+  setModelName: DocumentModelGlobalState;
+  setModuleDescription: DocumentModelGlobalState;
+  setModuleName: DocumentModelGlobalState;
+  setOperationDescription: DocumentModelGlobalState;
+  setOperationErrorCode: DocumentModelGlobalState;
+  setOperationErrorDescription: DocumentModelGlobalState;
+  setOperationErrorName: DocumentModelGlobalState;
+  setOperationErrorTemplate: DocumentModelGlobalState;
+  setOperationName: DocumentModelGlobalState;
+  setOperationReducer: DocumentModelGlobalState;
+  setOperationSchema: DocumentModelGlobalState;
+  setOperationTemplate: DocumentModelGlobalState;
+  setStateSchema: DocumentModelGlobalState;
+  updateChangeLogItemInput: DocumentModelGlobalState;
+  updateOperationExample: DocumentModelGlobalState;
+  updateStateExample: DocumentModelGlobalState;
+};
+type MutationAddChangeLogItemInputArgs = {
+  input?: InputMaybe<AddChangeLogItemInput>;
+};
+type MutationAddModuleArgs = {
+  input: AddModuleInput;
+};
+type MutationAddOperationArgs = {
+  input: AddOperationInput;
+};
+type MutationAddOperationErrorArgs = {
+  input: AddOperationErrorInput;
+};
+type MutationAddOperationExampleArgs = {
+  input: AddOperationExampleInput;
+};
+type MutationAddStateExampleArgs = {
+  input: AddStateExampleInput;
+};
+type MutationDeleteChangeLogItemInputArgs = {
+  input?: InputMaybe<DeleteChangeLogItemInput>;
+};
+type MutationDeleteModuleArgs = {
+  input: DeleteModuleInput;
+};
+type MutationDeleteOperationArgs = {
+  input: DeleteOperationInput;
+};
+type MutationDeleteOperationErrorArgs = {
+  input: DeleteOperationErrorInput;
+};
+type MutationDeleteOperationExampleArgs = {
+  input: DeleteOperationExampleInput;
+};
+type MutationDeleteStateExampleArgs = {
+  input: DeleteStateExampleInput;
+};
+type MutationMoveOperationArgs = {
+  input: MoveOperationInput;
+};
+type MutationReorderChangeLogItemsInputArgs = {
+  input?: InputMaybe<ReorderChangeLogItemsInput>;
+};
+type MutationReorderModuleOperationsArgs = {
+  input: ReorderModuleOperationsInput;
+};
+type MutationReorderModulesArgs = {
+  input: ReorderModulesInput;
+};
+type MutationReorderOperationErrorsArgs = {
+  input: ReorderOperationErrorsInput;
+};
+type MutationReorderOperationExamplesArgs = {
+  input: ReorderOperationExamplesInput;
+};
+type MutationReorderStateExamplesArgs = {
+  input: ReorderStateExamplesInput;
+};
+type MutationSetAuthorNameArgs = {
+  input: SetAuthorNameInput;
+};
+type MutationSetAuthorWebsiteArgs = {
+  input: SetAuthorWebsiteInput;
+};
+type MutationSetInitialStateArgs = {
+  input: SetInitialStateInput;
+};
+type MutationSetModelDescriptionArgs = {
+  input: SetModelDescriptionInput;
+};
+type MutationSetModelExtensionArgs = {
+  input: SetModelExtensionInput;
+};
+type MutationSetModelIdArgs = {
+  input: SetModelIdInput;
+};
+type MutationSetModelNameArgs = {
+  input: SetModelNameInput;
+};
+type MutationSetModuleDescriptionArgs = {
+  input: SetModuleDescriptionInput;
+};
+type MutationSetModuleNameArgs = {
+  input: SetModuleNameInput;
+};
+type MutationSetOperationDescriptionArgs = {
+  input: SetOperationDescriptionInput;
+};
+type MutationSetOperationErrorCodeArgs = {
+  input: SetOperationErrorCodeInput;
+};
+type MutationSetOperationErrorDescriptionArgs = {
+  input: SetOperationErrorDescriptionInput;
+};
+type MutationSetOperationErrorNameArgs = {
+  input: SetOperationErrorNameInput;
+};
+type MutationSetOperationErrorTemplateArgs = {
+  input: SetOperationErrorTemplateInput;
+};
+type MutationSetOperationNameArgs = {
+  input: SetOperationNameInput;
+};
+type MutationSetOperationReducerArgs = {
+  input: SetOperationReducerInput;
+};
+type MutationSetOperationSchemaArgs = {
+  input: SetOperationSchemaInput;
+};
+type MutationSetOperationTemplateArgs = {
+  input: SetOperationTemplateInput;
+};
+type MutationSetStateSchemaArgs = {
+  input: SetStateSchemaInput;
+};
+type MutationUpdateChangeLogItemInputArgs = {
+  input?: InputMaybe<UpdateChangeLogItemInput>;
+};
+type MutationUpdateOperationExampleArgs = {
+  input: UpdateOperationExampleInput;
+};
+type MutationUpdateStateExampleArgs = {
+  input: UpdateStateExampleInput;
+};
+type ReorderChangeLogItemsInput = {
+  __typename?: "ReorderChangeLogItemsInput";
+  order: Array<Scalars["ID"]["output"]>;
+};
+type ReorderModuleOperationsInput = {
+  moduleId: Scalars["ID"]["input"];
+  order: Array<Scalars["ID"]["input"]>;
+};
+type ReorderModulesInput = {
+  order: Array<Scalars["ID"]["input"]>;
+};
+type ReorderOperationErrorsInput = {
+  operationId: Scalars["ID"]["input"];
+  order: Array<Scalars["ID"]["input"]>;
+};
+type ReorderOperationExamplesInput = {
+  operationId: Scalars["ID"]["input"];
+  order: Array<Scalars["ID"]["input"]>;
+};
+type ReorderStateExamplesInput = {
+  scope: Scalars["String"]["input"];
+  order: Array<Scalars["ID"]["input"]>;
+};
+type SetAuthorNameInput = {
+  authorName: Scalars["String"]["input"];
+};
+type SetAuthorWebsiteInput = {
+  authorWebsite: Scalars["String"]["input"];
+};
+type SetInitialStateInput = {
+  scope: Scalars["String"]["input"];
+  initialValue: Scalars["String"]["input"];
+};
+type SetModelDescriptionInput = {
+  description: Scalars["String"]["input"];
+};
+type SetModelExtensionInput = {
+  extension: Scalars["String"]["input"];
+};
+type SetModelIdInput = {
+  id: Scalars["String"]["input"];
+};
+type SetModelNameInput = {
+  name: Scalars["String"]["input"];
+};
+type SetModuleDescriptionInput = {
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  id: Scalars["ID"]["input"];
+};
+type SetModuleNameInput = {
+  id: Scalars["ID"]["input"];
+  name?: InputMaybe<Scalars["String"]["input"]>;
+};
+type SetOperationDescriptionInput = {
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  id: Scalars["ID"]["input"];
+};
+type SetOperationErrorCodeInput = {
+  errorCode?: InputMaybe<Scalars["String"]["input"]>;
+  id: Scalars["ID"]["input"];
+};
+type SetOperationErrorDescriptionInput = {
+  errorDescription?: InputMaybe<Scalars["String"]["input"]>;
+  id: Scalars["ID"]["input"];
+};
+type SetOperationErrorNameInput = {
+  errorName?: InputMaybe<Scalars["String"]["input"]>;
+  id: Scalars["ID"]["input"];
+};
+type SetOperationErrorTemplateInput = {
+  errorTemplate?: InputMaybe<Scalars["String"]["input"]>;
+  id: Scalars["ID"]["input"];
+};
+type SetOperationNameInput = {
+  id: Scalars["ID"]["input"];
+  name?: InputMaybe<Scalars["String"]["input"]>;
+};
+type SetOperationScopeInput = {
+  id: Scalars["ID"]["input"];
+  scope?: InputMaybe<string>;
+};
+type SetOperationReducerInput = {
+  id: Scalars["ID"]["input"];
+  reducer?: InputMaybe<Scalars["String"]["input"]>;
+};
+type SetOperationSchemaInput = {
+  id: Scalars["ID"]["input"];
+  schema?: InputMaybe<Scalars["String"]["input"]>;
+};
+type SetOperationTemplateInput = {
+  id: Scalars["ID"]["input"];
+  template?: InputMaybe<Scalars["String"]["input"]>;
+};
+type SetStateSchemaInput = {
+  scope: Scalars["String"]["input"];
+  schema: Scalars["String"]["input"];
+};
+type UpdateChangeLogItemInput = {
+  __typename?: "UpdateChangeLogItemInput";
+  id: Scalars["ID"]["output"];
+  newContent: Scalars["String"]["output"];
+};
+type UpdateOperationExampleInput = {
+  example: Scalars["String"]["input"];
+  id: Scalars["ID"]["input"];
+};
+type UpdateStateExampleInput = {
+  scope: Scalars["String"]["input"];
+  id: Scalars["ID"]["input"];
+  newExample: Scalars["String"]["input"];
+};
+type SetModelNameAction = Action & {
+  type: "SET_MODEL_NAME";
+  input: SetModelNameInput;
+};
+type SetModelIdAction = Action & {
+  type: "SET_MODEL_ID";
+  input: SetModelIdInput;
+};
+type SetModelExtensionAction = Action & {
+  type: "SET_MODEL_EXTENSION";
+  input: SetModelExtensionInput;
+};
+type SetModelDescriptionAction = Action & {
+  type: "SET_MODEL_DESCRIPTION";
+  input: SetModelDescriptionInput;
+};
+type SetAuthorNameAction = Action & {
+  type: "SET_AUTHOR_NAME";
+  input: SetAuthorNameInput;
+};
+type SetAuthorWebsiteAction = Action & {
+  type: "SET_AUTHOR_WEBSITE";
+  input: SetAuthorWebsiteInput;
+};
+type DocumentModelHeaderAction = SetModelNameAction | SetModelIdAction | SetModelExtensionAction | SetModelDescriptionAction | SetAuthorNameAction | SetAuthorWebsiteAction;
+type AddModuleAction = Action & {
+  type: "ADD_MODULE";
+  input: AddModuleInput;
+};
+type SetModuleNameAction = Action & {
+  type: "SET_MODULE_NAME";
+  input: SetModuleNameInput;
+};
+type SetModuleDescriptionAction = Action & {
+  type: "SET_MODULE_DESCRIPTION";
+  input: SetModuleDescriptionInput;
+};
+type DeleteModuleAction = Action & {
+  type: "DELETE_MODULE";
+  input: DeleteModuleInput;
+};
+type ReorderModulesAction = Action & {
+  type: "REORDER_MODULES";
+  input: ReorderModulesInput;
+};
+type DocumentModelModuleAction = AddModuleAction | SetModuleNameAction | SetModuleDescriptionAction | DeleteModuleAction | ReorderModulesAction;
+type AddOperationAction = Action & {
+  type: "ADD_OPERATION";
+  input: AddOperationInput;
+};
+type SetOperationNameAction = Action & {
+  type: "SET_OPERATION_NAME";
+  input: SetOperationNameInput;
+};
+type SetOperationScopeAction = Action & {
+  type: "SET_OPERATION_SCOPE";
+  input: SetOperationScopeInput;
+};
+type SetOperationSchemaAction = Action & {
+  type: "SET_OPERATION_SCHEMA";
+  input: SetOperationSchemaInput;
+};
+type SetOperationDescriptionAction = Action & {
+  type: "SET_OPERATION_DESCRIPTION";
+  input: SetOperationDescriptionInput;
+};
+type SetOperationTemplateAction = Action & {
+  type: "SET_OPERATION_TEMPLATE";
+  input: SetOperationTemplateInput;
+};
+type SetOperationReducerAction = Action & {
+  type: "SET_OPERATION_REDUCER";
+  input: SetOperationReducerInput;
+};
+type MoveOperationAction = Action & {
+  type: "MOVE_OPERATION";
+  input: MoveOperationInput;
+};
+type DeleteOperationAction = Action & {
+  type: "DELETE_OPERATION";
+  input: DeleteOperationInput;
+};
+type ReorderModuleOperationsAction = Action & {
+  type: "REORDER_MODULE_OPERATIONS";
+  input: ReorderModuleOperationsInput;
+};
+type DocumentModelOperationAction = AddOperationAction | SetOperationNameAction | SetOperationScopeAction | SetOperationSchemaAction | SetOperationDescriptionAction | SetOperationTemplateAction | SetOperationReducerAction | MoveOperationAction | DeleteOperationAction | ReorderModuleOperationsAction;
+type AddOperationErrorAction = Action & {
+  type: "ADD_OPERATION_ERROR";
+  input: AddOperationErrorInput;
+};
+type SetOperationErrorCodeAction = Action & {
+  type: "SET_OPERATION_ERROR_CODE";
+  input: SetOperationErrorCodeInput;
+};
+type SetOperationErrorNameAction = Action & {
+  type: "SET_OPERATION_ERROR_NAME";
+  input: SetOperationErrorNameInput;
+};
+type SetOperationErrorDescriptionAction = Action & {
+  type: "SET_OPERATION_ERROR_DESCRIPTION";
+  input: SetOperationErrorDescriptionInput;
+};
+type SetOperationErrorTemplateAction = Action & {
+  type: "SET_OPERATION_ERROR_TEMPLATE";
+  input: SetOperationErrorTemplateInput;
+};
+type DeleteOperationErrorAction = Action & {
+  type: "DELETE_OPERATION_ERROR";
+  input: DeleteOperationErrorInput;
+};
+type ReorderOperationErrorsAction = Action & {
+  type: "REORDER_OPERATION_ERRORS";
+  input: ReorderOperationErrorsInput;
+};
+type DocumentModelOperationErrorAction = AddOperationErrorAction | SetOperationErrorCodeAction | SetOperationErrorNameAction | SetOperationErrorDescriptionAction | SetOperationErrorTemplateAction | DeleteOperationErrorAction | ReorderOperationErrorsAction;
+type AddOperationExampleAction = Action & {
+  type: "ADD_OPERATION_EXAMPLE";
+  input: AddOperationExampleInput;
+};
+type UpdateOperationExampleAction = Action & {
+  type: "UPDATE_OPERATION_EXAMPLE";
+  input: UpdateOperationExampleInput;
+};
+type DeleteOperationExampleAction = Action & {
+  type: "DELETE_OPERATION_EXAMPLE";
+  input: DeleteOperationExampleInput;
+};
+type ReorderOperationExamplesAction = Action & {
+  type: "REORDER_OPERATION_EXAMPLES";
+  input: ReorderOperationExamplesInput;
+};
+type DocumentModelOperationExampleAction = AddOperationExampleAction | UpdateOperationExampleAction | DeleteOperationExampleAction | ReorderOperationExamplesAction;
+type SetStateSchemaAction = Action & {
+  type: "SET_STATE_SCHEMA";
+  input: SetStateSchemaInput;
+};
+type SetInitialStateAction = Action & {
+  type: "SET_INITIAL_STATE";
+  input: SetInitialStateInput;
+};
+type AddStateExampleAction = Action & {
+  type: "ADD_STATE_EXAMPLE";
+  input: AddStateExampleInput;
+};
+type UpdateStateExampleAction = Action & {
+  type: "UPDATE_STATE_EXAMPLE";
+  input: UpdateStateExampleInput;
+};
+type DeleteStateExampleAction = Action & {
+  type: "DELETE_STATE_EXAMPLE";
+  input: DeleteStateExampleInput;
+};
+type ReorderStateExamplesAction = Action & {
+  type: "REORDER_STATE_EXAMPLES";
+  input: ReorderStateExamplesInput;
+};
+type DocumentModelStateAction = SetStateSchemaAction | SetInitialStateAction | AddStateExampleAction | UpdateStateExampleAction | DeleteStateExampleAction | ReorderStateExamplesAction;
+type AddChangeLogItemAction = Action & {
+  type: "ADD_CHANGE_LOG_ITEM";
+  input: AddChangeLogItemInput;
+};
+type UpdateChangeLogItemAction = Action & {
+  type: "UPDATE_CHANGE_LOG_ITEM";
+  input: UpdateChangeLogItemInput;
+};
+type DeleteChangeLogItemAction = Action & {
+  type: "DELETE_CHANGE_LOG_ITEM";
+  input: DeleteChangeLogItemInput;
+};
+type ReorderChangeLogItemsAction = Action & {
+  type: "REORDER_CHANGE_LOG_ITEMS";
+  input: ReorderChangeLogItemsInput;
+};
+type ReleaseNewVersionAction = Action & {
+  type: "RELEASE_NEW_VERSION";
+  input: {};
+};
+type DocumentModelVersioningAction = AddChangeLogItemAction | UpdateChangeLogItemAction | DeleteChangeLogItemAction | ReorderChangeLogItemsAction | ReleaseNewVersionAction;
+interface DocumentModelHeaderOperations {
+  setModelNameOperation: (state: DocumentModelGlobalState, action: SetModelNameAction) => void;
+  setModelIdOperation: (state: DocumentModelGlobalState, action: SetModelIdAction) => void;
+  setModelExtensionOperation: (state: DocumentModelGlobalState, action: SetModelExtensionAction) => void;
+  setModelDescriptionOperation: (state: DocumentModelGlobalState, action: SetModelDescriptionAction) => void;
+  setAuthorNameOperation: (state: DocumentModelGlobalState, action: SetAuthorNameAction) => void;
+  setAuthorWebsiteOperation: (state: DocumentModelGlobalState, action: SetAuthorWebsiteAction) => void;
+}
+interface DocumentModelModuleOperations {
+  addModuleOperation: (state: DocumentModelGlobalState, action: AddModuleAction) => void;
+  setModuleNameOperation: (state: DocumentModelGlobalState, action: SetModuleNameAction) => void;
+  setModuleDescriptionOperation: (state: DocumentModelGlobalState, action: SetModuleDescriptionAction) => void;
+  deleteModuleOperation: (state: DocumentModelGlobalState, action: DeleteModuleAction) => void;
+  reorderModulesOperation: (state: DocumentModelGlobalState, action: ReorderModulesAction) => void;
+}
+type DocumentModelOperationOperations = {
+  addOperationOperation: (state: DocumentModelGlobalState, action: AddOperationAction) => void;
+  setOperationNameOperation: (state: DocumentModelGlobalState, action: SetOperationNameAction) => void;
+  setOperationScopeOperation: (state: DocumentModelGlobalState, action: SetOperationScopeAction) => void;
+  setOperationSchemaOperation: (state: DocumentModelGlobalState, action: SetOperationSchemaAction) => void;
+  setOperationDescriptionOperation: (state: DocumentModelGlobalState, action: SetOperationDescriptionAction) => void;
+  setOperationTemplateOperation: (state: DocumentModelGlobalState, action: SetOperationTemplateAction) => void;
+  setOperationReducerOperation: (state: DocumentModelGlobalState, action: SetOperationReducerAction) => void;
+  moveOperationOperation: (state: DocumentModelGlobalState, action: MoveOperationAction) => void;
+  deleteOperationOperation: (state: DocumentModelGlobalState, action: DeleteOperationAction) => void;
+  reorderModuleOperationsOperation: (state: DocumentModelGlobalState, action: ReorderModuleOperationsAction) => void;
+};
+interface DocumentModelOperationErrorOperations {
+  addOperationErrorOperation: (state: DocumentModelGlobalState, action: AddOperationErrorAction) => void;
+  setOperationErrorCodeOperation: (state: DocumentModelGlobalState, action: SetOperationErrorCodeAction) => void;
+  setOperationErrorNameOperation: (state: DocumentModelGlobalState, action: SetOperationErrorNameAction) => void;
+  setOperationErrorDescriptionOperation: (state: DocumentModelGlobalState, action: SetOperationErrorDescriptionAction) => void;
+  setOperationErrorTemplateOperation: (state: DocumentModelGlobalState, action: SetOperationErrorTemplateAction) => void;
+  deleteOperationErrorOperation: (state: DocumentModelGlobalState, action: DeleteOperationErrorAction) => void;
+  reorderOperationErrorsOperation: (state: DocumentModelGlobalState, action: ReorderOperationErrorsAction) => void;
+}
+interface DocumentModelOperationExampleOperations {
+  addOperationExampleOperation: (state: DocumentModelGlobalState, action: AddOperationExampleAction) => void;
+  updateOperationExampleOperation: (state: DocumentModelGlobalState, action: UpdateOperationExampleAction) => void;
+  deleteOperationExampleOperation: (state: DocumentModelGlobalState, action: DeleteOperationExampleAction) => void;
+  reorderOperationExamplesOperation: (state: DocumentModelGlobalState, action: ReorderOperationExamplesAction) => void;
+}
+interface DocumentModelStateOperations {
+  setStateSchemaOperation: (state: DocumentModelGlobalState, action: SetStateSchemaAction) => void;
+  setInitialStateOperation: (state: DocumentModelGlobalState, action: SetInitialStateAction) => void;
+  addStateExampleOperation: (state: DocumentModelGlobalState, action: AddStateExampleAction) => void;
+  updateStateExampleOperation: (state: DocumentModelGlobalState, action: UpdateStateExampleAction) => void;
+  deleteStateExampleOperation: (state: DocumentModelGlobalState, action: DeleteStateExampleAction) => void;
+  reorderStateExamplesOperation: (state: DocumentModelGlobalState, action: ReorderStateExamplesAction) => void;
+}
+interface DocumentModelVersioningOperations {
+  addChangeLogItemOperation: (state: DocumentModelGlobalState, action: AddChangeLogItemAction) => void;
+  updateChangeLogItemOperation: (state: DocumentModelGlobalState, action: UpdateChangeLogItemAction) => void;
+  deleteChangeLogItemOperation: (state: DocumentModelGlobalState, action: DeleteChangeLogItemAction) => void;
+  reorderChangeLogItemsOperation: (state: DocumentModelGlobalState, action: ReorderChangeLogItemsAction) => void;
+  releaseNewVersionOperation: (state: DocumentModelGlobalState, action: ReleaseNewVersionAction) => void;
+}
+type Maybe<T> = T | null;
+type InputMaybe<T> = T | null | undefined;
+type Exact<T extends Record<string, unknown>> = { [K in keyof T]: T[K] };
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
+type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
+type MakeEmpty<T extends Record<string, unknown>, K extends keyof T> = { [_ in K]?: never };
+type Incremental<T> = T | { [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never };
+/** All built-in and custom scalars, mapped to their actual values */
+type Scalars = {
+  ID: {
+    input: string;
+    output: string;
+  };
+  String: {
+    input: string;
+    output: string;
+  };
+  Boolean: {
+    input: boolean;
+    output: boolean;
+  };
+  Int: {
+    input: number;
+    output: number;
+  };
+  Float: {
+    input: number;
+    output: number;
+  };
+  Address: {
+    input: `${string}:0x${string}`;
+    output: `${string}:0x${string}`;
+  };
+  AttachmentRef: {
+    input: `attachment://v${number}:${string}`;
+    output: `attachment://v${number}:${string}`;
+  };
+  DateTime: {
+    input: string;
+    output: string;
+  };
+  Unknown: {
+    input: unknown;
+    output: unknown;
+  };
+};
+type ID = string;
+type OperationsByScope = Partial<Record<string, Operation[]>>;
+type SkipHeaderOperationIndex = Partial<Pick<OperationIndex, "index">> & Pick<OperationIndex, "skip">;
+type UndoRedoAction = SchemaRedoAction | SchemaUndoAction;
+type IAction = {
+  type: Scalars["String"]["output"];
+};
+type IDocument = {
+  created: Scalars["DateTime"]["output"];
+  documentType: Scalars["String"]["output"];
+  lastModified: Scalars["DateTime"]["output"];
+  name: Scalars["String"]["output"];
+  operations: Array<IOperation>;
+  revision: Scalars["Int"]["output"];
+};
+type IOperation = {
+  hash: Scalars["String"]["output"];
+  index: Scalars["Int"]["output"];
+  timestampUtcMs: Scalars["DateTime"]["output"];
+  type: Scalars["String"]["output"];
+};
+type Load_State = "LOAD_STATE";
+type SchemaLoadStateAction = {
+  id: Scalars["String"]["output"];
+  timestampUtcMs: Scalars["DateTime"]["output"];
+  input: LoadStateActionInput;
+  type: Load_State;
+  scope: string;
+};
+type LoadStateActionInput = {
+  operations: Scalars["Int"]["input"];
+  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;
+  /**
+   * Per-scope next-operation-index snapshot at the moment the upgrade executes.
+   * Absent on legacy operations; loaders fall back to timestamp ordering when missing.
+   * Stamped CLIENT-SIDE at action creation (before signing), NEVER at execution.
+   */
+  revision?: Record<string, number>;
+};
+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;
+};
+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;
+};
+/**
+ * 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;
+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>;
+/**
+ * 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 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;
+};
+type ActionErrorCallback = (error: unknown) => void;
+type EditorDispatch = (action: Action, onErrorCallback?: ActionErrorCallback) => void;
+type EditorProps = {
+  children?: ReactNode;
+  className?: string;
+  document?: PHDocument;
+};
+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;
+  };
+};
+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;
+};
+/**
+ * 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;
+};
+/**
+ * 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 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 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 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 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 { DocumentModelDocumentModelModule as $, RedoActionSchema as $a, merge as $c, UpdateChangeLogItemInput as $i, OperationSpecification as $n, IRelationalQueryBuilder as $o, SetModelIdInput as $r, reorderOperationExamples as $s, MinimalBackupData as $t, CreateDocument as A, DeleteOperationInputSchema as Aa, PHDocument as Ac, SetPreferredEditorActionInput as Ai, createDocumentState as Al, MutationSetModelExtensionArgs as An, SetPreferredEditorActionSchema as Ao, RevisionsFilter as Ar, buildSignedAction as As, IAction as At, DeleteModuleAction as B, ManifestSchema as Ba, filterDuplicatedOperations as Bc, SignalType as Bi, ActionSigner as Bl, MutationSetOperationErrorTemplateArgs as Bn, UpdateStateExampleInputSchema as Bo, SchemaUndoAction as Br, moveOperation as Bs, IsStateOfType as Bt, CodeExample as C, CodeExampleSchema as Ca, undo as Cc, SetOperationSchemaAction as Ci, undoOperation as Cl, MutationReorderOperationErrorsArgs as Cn, SetOperationErrorTemplateInputSchema as Co, ReorderOperationErrorsAction as Cr, addModule as Cs, ENSInfo as Ct, CopyChildDocumentSignal as D, DeleteModuleInputSchema as Da, verifyOperationSignature as Dc, SetOperationTemplateAction as Di, PHDocumentState as Dl, MutationSetAuthorWebsiteArgs as Dn, SetOperationScopeInputSchema as Do, ReorderStateExamplesAction as Dr, addStateExample as Ds, Exact as Dt, CopyChildDocumentInput as E, DeleteChangeLogItemInputSchema as Ea, updateStateExample as Ec, SetOperationScopeInput as Ei, PHBaseState as El, MutationSetAuthorNameArgs as En, SetOperationSchemaInputSchema as Eo, ReorderOperationExamplesInput as Er, addOperationExample as Es, EditorProps as Et, DeleteChangeLogItemInput as F, DocumentSpecificationSchema as Fa, baseCreateDocument as Fc, Set_PreferredEditor as Fi, defaultBaseState as Fl, MutationSetNameArgs as Fn, UndoActionInputSchema as Fo, SchemaNOOPAction as Fr, deleteOperationError as Fs, ISignalResult as Ft, DeleteOperationExampleAction as G, OperationSpecificationSchema as Ga, groupOperationsByScope as Gc, State as Gi, UserActionSigner as Gl, MutationSetStateSchemaArgs as Gn, createRelationalDb as Go, SetAuthorWebsiteInput as Gr, operationWithContext as Gs, LoadStateActionStateInput as Gt, DeleteOperationAction as H, MoveOperationInputSchema as Ha, garbageCollectDocumentOperations as Hc, SigningParameters as Hi, HashConfig as Hl, MutationSetOperationReducerArgs as Hn, isDefinedNonNullAny as Ho, SetAuthorNameAction as Hr, operationExampleCreators as Hs, LoadFromInput as Ht, DeleteChildDocumentInput as I, LoadStateActionInputSchema as Ia, checkCleanedOperationsIntegrity as Ic, Signal as Ii, defaultDocumentState as Il, MutationSetOperationDescriptionArgs as In, UndoActionSchema as Io, SchemaPruneAction as Ir, deleteOperationExample as Is, ISigner as It, DeleteStateExampleAction as J, PruneActionInputSchema as Ja, isNoopOperation as Jc, Undo as Ji, PROCESSOR_APPS as Jl, MutationUpdateOperationExampleArgs as Jn, ExtractProcessorSchemaOrSelf as Jo, SetModelDescriptionAction as Jr, releaseNewVersion as Js, MakeMaybe as Jt, DeleteOperationExampleInput as K, PowerhouseModuleSchema as Ka, hashDocumentStateForScope as Kc, StateReducer as Ki, DEFAULT_ANALYTICS_PROCESSOR_DB_NAME as Kl, MutationUndoArgs as Kn, hashNamespace as Ko, SetInitialStateAction as Kr, prune as Ks, Load_State as Kt, DeleteChildDocumentSignal as L, LoadStateActionSchema as La, checkOperationsIntegrity as Lc, SignalDispatch as Li, defaultGlobalState as Ll, MutationSetOperationErrorCodeArgs as Ln, UndoSchema as Lo, SchemaRedoAction as Lr, deleteStateExample as Ls, Incremental as Lt, CreateDocumentActionInput as M, DocumentActionSchema as Ma, PHDocumentMeta as Mc, SetStateSchemaAction as Mi, createLocalState as Ml, MutationSetModelNameArgs as Mn, Set_NameSchema as Mo, SaveToFileHandle as Mr, deleteChangeLogItem as Ms, IDocument as Mt, CreateState as N, DocumentModelGlobalStateSchema as Na, addUndo as Nc, SetStateSchemaInput as Ni, createState as Nl, MutationSetModuleDescriptionArgs as Nn, Set_PreferredEditorSchema as No, Scalars as Nr, deleteModule as Ns, IOperation as Nt, CreateChildDocumentInput as O, DeleteOperationErrorInputSchema as Oa, IntegrityIssueSubType as Oc, SetOperationTemplateInput as Oi, createAuthState as Ol, MutationSetInitialStateArgs as On, SetOperationTemplateInputSchema as Oo, ReorderStateExamplesInput as Or, baseActions as Os, FileInput as Ot, DeleteChangeLogItemAction as P, DocumentModelInputSchema as Pa, attachBranch as Pc, Set_Name as Pi, defaultAuthState as Pl, MutationSetModuleNameArgs as Pn, StateSchema as Po, SchemaLoadStateAction as Pr, deleteOperation as Ps, ISignal as Pt, DocumentModelDocument as Q, RedoActionInputSchema as Qa, mapSkippedOperationsV2 as Qc, UpdateChangeLogItemAction as Qi, OperationIndex as Qn, IRelationalDbProcessor as Qo, SetModelIdAction as Qr, reorderOperationErrors as Qs, Maybe as Qt, DeleteDocumentAction as R, LoadStateActionStateInputSchema as Ra, diffOperations as Rc, SignalResult as Ri, defaultLocalState as Rl, MutationSetOperationErrorDescriptionArgs as Rn, UpdateChangeLogItemInputSchema as Ro, SchemaSetNameAction as Rr, documentModelActions as Rs, InputMaybe as Rt, Author as S, AuthorSchema as Sa, setStateSchema as Sc, SetOperationReducerInput as Si, setPreferredEditorOperation as Sl, MutationReorderModulesArgs as Sn, SetOperationErrorNameInputSchema as So, ReorderModulesInput as Sr, addChangeLogItem as Ss, DocumentSpecification as St, ConfigEntryType as T, ConfigEntryTypeSchema as Ta, updateOperationExample as Tc, SetOperationScopeAction as Ti, PHAuthState as Tl, MutationReorderStateExamplesArgs as Tn, SetOperationReducerInputSchema as To, ReorderOperationExamplesAction as Tr, addOperationError as Ts, EditorModule as Tt, DeleteOperationErrorAction as U, OperationErrorSchema as Ua, garbageCollectV2 as Uc, SkipHeaderOperationIndex as Ui, PHDocumentSignatureInfo as Ul, MutationSetOperationSchemaArgs as Un, createNamespacedDb as Uo, SetAuthorNameInput as Ur, operationFromAction as Us, LoadStateAction as Ut, DeleteModuleInput as V, ModuleSchema as Va, garbageCollect as Vc, SignatureVerificationHandler as Vi, AppActionSigner as Vl, MutationSetOperationNameArgs as Vn, definedNonNullAnySchema as Vo, ScopeState as Vr, noop as Vs, LoadFromFile as Vt, DeleteOperationErrorInput as W, OperationScopeSchema as Wa, getDocumentLastModified as Wc, SkipHeaderOperations as Wi, Signature as Wl, MutationSetOperationTemplateArgs as Wn, createNamespacedQueryBuilder as Wo, SetAuthorWebsiteAction as Wr, operationFromOperation as Ws, LoadStateActionInput as Wt, DocumentAction as X, PruneSchema as Xa, isUndoRedo as Xc, UndoActionInput as Xi, NOOPAction as Xn, IBaseRelationalDb as Xo, SetModelExtensionAction as Xr, reorderModuleOperations as Xs, Manifest as Xt, DeleteStateExampleInput as Y, PruneActionSchema as Ya, isUndo as Yc, UndoAction as Yi, MutationUpdateStateExampleArgs as Yn, HashAlgorithms as Yo, SetModelDescriptionInput as Yr, reorderChangeLogItems as Ys, MakeOptional as Yt, DocumentModelAction as Z, PublisherSchema as Za, mapSkippedOperations as Zc, UndoRedoAction as Zi, OperationErrorSpecification as Zn, IRelationalDb as Zo, SetModelExtensionInput as Zr, reorderModules as Zs, MappedOperation as Zt, AddRelationshipActionInput as _, AddModuleInputSchema as _a, setOperationReducer as _c, SetOperationErrorTemplateAction as _i, OperationContext as _l, MutationMoveOperationArgs as _n, SetNameActionInputSchema as _o, ReorderChangeLogItemsAction as _r, ActionContext as _s, DocumentModelStateOperations as _t, Actions as a, UpdateStateExampleInput as aa, setModelExtension as ac, SetModuleNameInput as ai, readOnly as al, MutationAddModuleArgs as an, ReorderOperationExamplesInputSchema as ao, PruneAction as ar, IProcessorHostModule as as, DocumentModelLocalState as at, AssertIsDocumentOfType as b, AddOperationInputSchema as ba, setOperationTemplate as bc, SetOperationNameInput as bi, redoOperation as bl, MutationReorderChangeLogItemsInputArgs as bn, SetOperationErrorCodeInputSchema as bo, ReorderModuleOperationsInput as br, actionSigner as bs, DocumentModelVersioningOperations as bt, AddModuleAction as c, User as ca, setModuleDescription as cc, SetNameOperation as ci, reshuffleByTimestamp as cl, MutationAddOperationExampleArgs as cn, SetAuthorNameInputSchema as co, Query as cr, ProcessorApps as cs, DocumentModelModuleOperations as ct, AddOperationErrorAction as d, UpgradeReducer as da, setOperationDescription as dc, SetOperationErrorCodeAction as di, sortMappedOperations as dl, MutationDeleteModuleArgs as dn, SetModelDescriptionInputSchema as do, RedoActionInput as dr, ProcessorFactoryBuilder as ds, DocumentModelOperationErrorOperations as dt, UpdateOperationExampleAction as ea, reorderStateExamples as ec, SetModelNameAction as ei, nextSkipNumber as el, ModuleSpecification as en, RedoSchema as eo, OperationsByScope as er, IRelationalQueryMethods as es, DocumentModelGlobalState as et, AddOperationErrorInput as f, UpgradeTransition as fa, setOperationErrorCode as fc, SetOperationErrorCodeInput as fi, sortOperations as fl, MutationDeleteOperationArgs as fn, SetModelExtensionInputSchema as fo, Reducer as fr, ProcessorFilter as fs, DocumentModelOperationExampleAction as ft, AddRelationshipAction as g, AddChangeLogItemInputSchema as ga, setOperationName as gc, SetOperationErrorNameInput as gi, Operation as gl, MutationLoadStateArgs as gn, SetModuleNameInputSchema as go, RemoveRelationshipActionInput as gr, Action as gs, DocumentModelStateAction as gt, AddOperationInput as h, computeUpgradeTransitions as ha, setOperationErrorTemplate as hc, SetOperationErrorNameAction as hi, DocumentOperations as hl, MutationDeleteStateExampleArgs as hn, SetModuleDescriptionInputSchema as ho, RemoveRelationshipAction as hr, TrackedProcessor as hs, DocumentModelPHState as ht, ActionVerificationHandler as i, UpdateStateExampleAction as ia, setModelDescription as ic, SetModuleNameAction as ii, prepareOperations as il, MutationAddChangeLogItemInputArgs as in, ReorderOperationErrorsInputSchema as io, Prune as ir, IProcessorDispatch as is, DocumentModelLib as it, CreateDocumentAction as j, DeleteStateExampleInputSchema as ja, PHDocumentHeader as jc, SetPreferredEditorOperation as ji, createGlobalState as jl, MutationSetModelIdArgs as jn, SetStateSchemaInputSchema as jo, SaveToFile as jr, createAction as js, ID as jt, CreateChildDocumentSignal as k, DeleteOperationExampleInputSchema as ka, IntegrityIssueType as kc, SetPreferredEditorAction as ki, createBaseState as kl, MutationSetModelDescriptionArgs as kn, SetPreferredEditorActionInputSchema as ko, ReplayDocumentOptions as kr, buildOperationSignature as ks, GetDocumentOptions as kt, AddModuleInput as l, ValidationError as la, setModuleName as lc, SetOperationDescriptionAction as li, reshuffleByTimestampAndIndex as ll, MutationAddStateExampleArgs as ln, SetAuthorWebsiteInputSchema as lo, Redo as lr, ProcessorDispatchResult as ls, DocumentModelOperationAction as lt, AddOperationExampleInput as m, applyUpgradeDocumentAction as ma, setOperationErrorName as mc, SetOperationErrorDescriptionInput as mi, updateHeaderRevision as ml, MutationDeleteOperationExampleArgs as mn, SetModelNameInputSchema as mo, ReleaseNewVersionAction as mr, ProcessorStatus as ms, DocumentModelOperationOperations as mt, ActionSignatureContext as n, UpdateRelationshipAction as na, setAuthorWebsite as nc, SetModuleDescriptionAction as ni, parseResultingState as nl, MoveOperationInput as nn, ReorderModuleOperationsInputSchema as no, PartialState as nr, RelationalDbProcessorClass as ns, DocumentModelHeaderOperations as nt, AddChangeLogItemAction as o, UpgradeDocumentAction as oa, setModelId as oc, SetNameAction as oi, removeExistingOperations as ol, MutationAddOperationArgs as on, ReorderStateExamplesInputSchema as oo, PruneActionInput as or, IProcessorManager as os, DocumentModelModule as ot, AddOperationExampleAction as p, applyDeleteDocumentAction as pa, setOperationErrorDescription as pc, SetOperationErrorDescriptionAction as pi, split as pl, MutationDeleteOperationErrorArgs as pn, SetModelIdInputSchema as po, ReducerOptions as pr, ProcessorRecord as ps, DocumentModelOperationExampleOperations as pt, DeleteOperationInput as q, PowerhouseModulesSchema as qa, isDocumentAction as qc, SubgraphModule as qi, DEFAULT_RELATIONAL_PROCESSOR_DB_NAME as ql, MutationUpdateChangeLogItemInputArgs as qn, relationalDbToQueryBuilder as qo, SetInitialStateInput as qr, redo as qs, MakeEmpty as qt, ActionSigningHandler as r, UpdateRelationshipActionInput as ra, setInitialState as rc, SetModuleDescriptionInput as ri, precedes as rl, Mutation as rn, ReorderModulesInputSchema as ro, PowerhouseModule as rr, IProcessor as rs, DocumentModelInput as rt, AddChangeLogItemInput as s, UpgradeDocumentActionInput as sa, setModelName as sc, SetNameActionInput as si, replayDocument as sl, MutationAddOperationErrorArgs as sn, ScopeStateSchema as so, Publisher as sr, ProcessorApp as ss, DocumentModelModuleAction as st, ActionErrorCallback as t, UpdateOperationExampleInput as ta, setAuthorName as tc, SetModelNameInput as ti, operationsAreEqual as tl, MoveOperationAction as tn, ReorderChangeLogItemsInputSchema as to, PartialRecord as tr, RelationalDbProcessor as ts, DocumentModelHeaderAction as tt, AddOperationAction as u, UpgradeManifest as ua, setName as uc, SetOperationDescriptionInput as ui, skipHeaderOperations as ul, MutationDeleteChangeLogItemInputArgs as un, SetInitialStateInputSchema as uo, RedoAction as ur, ProcessorFactory as us, DocumentModelOperationErrorAction as ut, AddStateExampleAction as v, AddOperationErrorInputSchema as va, setOperationSchema as vc, SetOperationErrorTemplateInput as vi, OperationWithContext$1 as vl, MutationPruneArgs as vn, SetNameActionSchema as vo, ReorderChangeLogItemsInput as vr, actionContext as vs, DocumentModelUtils as vt, ConfigEntry as w, ConfigEntrySchema as wa, updateChangeLogItem as wc, SetOperationSchemaInput as wi, undoOperationV2 as wl, MutationReorderOperationExamplesArgs as wn, SetOperationNameInputSchema as wo, ReorderOperationErrorsInput as wr, addOperation as ws, EditorDispatch as wt, AssertIsStateOfType as x, AddStateExampleInputSchema as xa, setPreferredEditor as xc, SetOperationReducerAction as xi, setNameOperation as xl, MutationReorderModuleOperationsArgs as xn, SetOperationErrorDescriptionInputSchema as xo, ReorderModulesAction as xr, actions as xs, DocumentOperationsIgnoreMap as xt, AddStateExampleInput as y, AddOperationExampleInputSchema as ya, setOperationScope as yc, SetOperationNameAction as yi, loadStateOperation as yl, MutationRedoArgs as yn, SetOperationDescriptionInputSchema as yo, ReorderModuleOperationsAction as yr, actionFromAction as ys, DocumentModelVersioningAction as yt, DeleteDocumentActionInput as z, Load_StateSchema as za, filterDocumentOperationsResultingState as zc, SignalResults as zi, defaultPHState as zl, MutationSetOperationErrorNameArgs as zn, UpdateOperationExampleInputSchema as zo, SchemaSetPreferredEditorAction as zr, loadState as zs, IsDocumentOfType as zt };
+//# sourceMappingURL=types-Bo4Rb8Yf.d.ts.map