document-model 1.0.14 → 1.0.16

package/dist/browser/document/actions/creators.d.ts

@@ -43,4 +43,4 @@ export declare const prune: (start?: number | undefined, end?: number | undefine
  * @param operations - Number of operations that were removed from the previous state.
  * @category Actions
  */
-export declare const loadState: (state: Pick<ExtendedState, 'state' | 'name'>, operations: number) => LoadStateAction;
+export declare const loadState: <S, T>(state: Pick<ExtendedState<S, T>, "name" | "state">, operations: number) => LoadStateAction;

package/dist/browser/document/actions/index.d.ts

@@ -1,10 +1,10 @@
-import { Action, Document, ImmutableStateReducer } from '../types';
-export declare function setNameOperation<T, A extends Action>(document: Document<T, A>, name: string): Document<T, A>;
-export declare function undoOperation<T, A extends Action>(document: Document<T, A>, count: number, wrappedReducer: ImmutableStateReducer<T, A>): Document<T, A>;
-export declare function redoOperation<T, A extends Action>(document: Document<T, A>, count: number, wrappedReducer: ImmutableStateReducer<T, A>): Document<T, A>;
-export declare function pruneOperation<T, A extends Action>(document: Document<T, A>, start: number | null | undefined, end: number | null | undefined, wrappedReducer: ImmutableStateReducer<T, A>): Document<T, A>;
-export declare function loadStateOperation<T, A extends Action>(oldDocument: Document<T, A>, newDocument: {
+import { Action, Document, ImmutableStateReducer, State } from '../types';
+export declare function setNameOperation<T>(document: T, name: string): T;
+export declare function undoOperation<T, A extends Action, L>(document: Document<T, A, L>, count: number, wrappedReducer: ImmutableStateReducer<T, A, L>): Document<T, A, L>;
+export declare function redoOperation<T, A extends Action, L>(document: Document<T, A, L>, count: number, wrappedReducer: ImmutableStateReducer<T, A, L>): Document<T, A, L>;
+export declare function pruneOperation<T, A extends Action, L>(document: Document<T, A, L>, start: number | null | undefined, end: number | null | undefined, wrappedReducer: ImmutableStateReducer<T, A, L>): Document<T, A, L>;
+export declare function loadStateOperation<T, A extends Action, L>(oldDocument: Document<T, A, L>, newDocument: {
     name: string;
-    state?: T;
-}): Document<T, A>;
+    state?: State<T, L>;
+}): Document<T, A, L>;
 export * from './creators';

package/dist/browser/document/object.d.ts

@@ -7,8 +7,8 @@ import type { Action, AttachmentRef, Document, ExtendedState, Reducer } from './
  * @typeparam T - The type of data stored in the document.
  * @typeparam A - The type of action the document can take.
  */
-export declare abstract class BaseDocument<T, A extends Action> {
-    protected _document: Document<T, A>;
+export declare abstract class BaseDocument<T, A extends Action, L = unknown> {
+    protected _document: Document<T, A, L>;
     private _reducer;
     private _signalDispatch?;
     /**
@@ -16,7 +16,7 @@ export declare abstract class BaseDocument<T, A extends Action> {
      * @param reducer - The reducer function that updates the state.
      * @param document - The initial state of the document.
      */
-    constructor(reducer: Reducer<T, A>, document: Document<T, A>, signalDispatch?: SignalDispatch);
+    constructor(reducer: Reducer<T, A, L>, document: Document<T, A, L>, signalDispatch?: SignalDispatch);
     /**
      * Dispatches an action to update the state of the document.
      * @param action - The action to dispatch.
@@ -41,60 +41,69 @@ export declare abstract class BaseDocument<T, A extends Action> {
      * @param reducer - The reducer function that updates the state.
      * @returns The state of the document.
      */
-    protected static stateFromFile<T, A extends Action>(path: string, reducer: Reducer<T, A>): Promise<Document<T, A>>;
+    protected static stateFromFile<T, A extends Action, L>(path: string, reducer: Reducer<T, A, L>): Promise<Document<T, A, L>>;
     /**
      *    Gets the current state of the document.
      */
-    get state(): import("immer").Immutable<T>;
+    get state(): {
+        readonly global: import("immer").Immutable<T>;
+        readonly local: import("immer").Immutable<L>;
+    };
     /**
      *    Gets the list of operations performed on the document.
      */
-    get operations(): readonly ({
-        readonly input: {
-            readonly operations: number;
-            readonly state: {
-                readonly data?: unknown;
-                readonly name: string;
+    get operations(): {
+        readonly global: readonly ({
+            readonly input: {
+                readonly operations: number;
+                readonly state: {
+                    readonly data?: unknown;
+                    readonly name: string;
+                };
             };
-        };
-        readonly type: "LOAD_STATE";
-        readonly index: number;
-        readonly timestamp: string;
-        readonly hash: string;
-    } | {
-        readonly input: {
-            readonly end?: import("./types").InputMaybe<number>;
-            readonly start?: import("./types").InputMaybe<number>;
-        };
-        readonly type: "PRUNE";
-        readonly index: number;
-        readonly timestamp: string;
-        readonly hash: string;
-    } | {
-        readonly input: number;
-        readonly type: "REDO";
-        readonly index: number;
-        readonly timestamp: string;
-        readonly hash: string;
-    } | {
-        readonly input: string;
-        readonly type: "SET_NAME";
-        readonly index: number;
-        readonly timestamp: string;
-        readonly hash: string;
-    } | {
-        readonly input: number;
-        readonly type: "UNDO";
-        readonly index: number;
-        readonly timestamp: string;
-        readonly hash: string;
-    } | import("immer").Immutable<A & {
-        index: number;
-        timestamp: string;
-        hash: string; /**
-         * Gets the timestamp of the date the document was created.
-         */
-    }>)[];
+            readonly type: "LOAD_STATE";
+            readonly scope: "global";
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+        } | {
+            readonly input: {
+                readonly end?: import("./types").InputMaybe<number>;
+                readonly start?: import("./types").InputMaybe<number>;
+            };
+            readonly type: "PRUNE";
+            readonly scope: "global";
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+        } | {
+            readonly input: number;
+            readonly type: "REDO";
+            readonly scope: "global";
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+        } | {
+            readonly input: string;
+            readonly type: "SET_NAME";
+            readonly scope: "global";
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+        } | {
+            readonly input: number;
+            readonly type: "UNDO";
+            readonly scope: "global";
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+        } | import("immer").Immutable<A & {
+            index: number;
+            timestamp: string;
+            hash: string;
+        }>)[];
+        readonly local: readonly import("immer").Immutable<import("./types").Operation<A>>[];
+    };
     /**
      * Gets the name of the document.
      */
@@ -124,7 +133,10 @@ export declare abstract class BaseDocument<T, A extends Action> {
         readonly documentType: string;
         readonly created: string;
         readonly lastModified: string;
-        readonly state: import("immer").Immutable<T>;
+        readonly state: {
+            readonly global: import("immer").Immutable<T>;
+            readonly local: import("immer").Immutable<L>;
+        };
         readonly attachments: {
             readonly [x: string]: {
                 readonly data: string;
@@ -143,7 +155,10 @@ export declare abstract class BaseDocument<T, A extends Action> {
         readonly documentType: string;
         readonly created: string;
         readonly lastModified: string;
-        readonly state: import("immer").Immutable<T>;
+        readonly state: {
+            readonly global: import("immer").Immutable<T>;
+            readonly local: import("immer").Immutable<L>;
+        };
         readonly attachments: {
             readonly [x: string]: {
                 readonly data: string;
@@ -152,59 +167,68 @@ export declare abstract class BaseDocument<T, A extends Action> {
                 readonly fileName?: string | null | undefined;
             };
         };
-        readonly operations: readonly ({
-            readonly input: {
-                readonly operations: number;
-                readonly state: {
-                    readonly data?: unknown;
-                    readonly name: string;
+        readonly operations: {
+            readonly global: readonly ({
+                readonly input: {
+                    readonly operations: number;
+                    readonly state: {
+                        readonly data?: unknown;
+                        readonly name: string;
+                    };
                 };
-            };
-            readonly type: "LOAD_STATE";
-            readonly index: number;
-            readonly timestamp: string;
-            readonly hash: string;
-        } | {
-            readonly input: {
-                readonly end?: import("./types").InputMaybe<number>;
-                readonly start?: import("./types").InputMaybe<number>;
-            };
-            readonly type: "PRUNE";
-            readonly index: number;
-            readonly timestamp: string;
-            readonly hash: string;
-        } | {
-            readonly input: number;
-            readonly type: "REDO";
-            readonly index: number;
-            readonly timestamp: string;
-            readonly hash: string;
-        } | {
-            readonly input: string;
-            readonly type: "SET_NAME";
-            readonly index: number;
-            readonly timestamp: string;
-            readonly hash: string;
-        } | {
-            readonly input: number;
-            readonly type: "UNDO";
-            readonly index: number;
-            readonly timestamp: string;
-            readonly hash: string;
-        } | import("immer").Immutable<A & {
-            index: number;
-            timestamp: string;
-            hash: string; /**
-             * Gets the timestamp of the date the document was created.
-             */
-        }>)[];
+                readonly type: "LOAD_STATE";
+                readonly scope: "global";
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+            } | {
+                readonly input: {
+                    readonly end?: import("./types").InputMaybe<number>;
+                    readonly start?: import("./types").InputMaybe<number>;
+                };
+                readonly type: "PRUNE";
+                readonly scope: "global";
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+            } | {
+                readonly input: number;
+                readonly type: "REDO";
+                readonly scope: "global";
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+            } | {
+                readonly input: string;
+                readonly type: "SET_NAME";
+                readonly scope: "global";
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+            } | {
+                readonly input: number;
+                readonly type: "UNDO";
+                readonly scope: "global";
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+            } | import("immer").Immutable<A & {
+                index: number;
+                timestamp: string;
+                hash: string;
+            }>)[];
+            readonly local: readonly import("immer").Immutable<import("./types").Operation<A>>[];
+        };
         readonly initialState: {
             readonly name: string;
             readonly revision: number;
             readonly documentType: string;
             readonly created: string;
             readonly lastModified: string;
-            readonly state: import("immer").Immutable<T>;
+            readonly state: {
+                readonly global: import("immer").Immutable<T>;
+                readonly local: import("immer").Immutable<L>;
+            };
             readonly attachments: {
                 readonly [x: string]: {
                     readonly data: string;
@@ -246,7 +270,7 @@ export declare abstract class BaseDocument<T, A extends Action> {
      * @param state - The state to load.
      * @param operations - The operations to apply to the document.
      */
-    loadState(state: Pick<ExtendedState<T>, 'state' | 'name'>, operations: number): this;
+    loadState(state: Pick<ExtendedState<T, L>, 'state' | 'name'>, operations: number): this;
 }
 /**
  * Applies multiple mixins to a base class.

package/dist/browser/document/reducer.d.ts

@@ -13,4 +13,4 @@ import { SignalDispatch } from './signal';
  * specific to the document's state.
  * @returns The new state of the document.
  */
-export declare function baseReducer<T, A extends Action>(document: Document<T, A>, action: A | BaseAction, customReducer: ImmutableStateReducer<T, A>, dispatch?: SignalDispatch): Document<T, A>;
+export declare function baseReducer<T, A extends Action, L>(document: Document<T, A, L>, action: A | BaseAction, customReducer: ImmutableStateReducer<T, A, L>, dispatch?: SignalDispatch): Document<T, A, L>;

package/dist/browser/document/schema/types.d.ts

@@ -91,6 +91,7 @@ export type Load_State = 'LOAD_STATE';
 export type LoadStateAction = {
     input: LoadStateActionInput;
     type: Load_State | `${Load_State}`;
+    scope: "global";
 };
 export type LoadStateActionInput = {
     operations: Scalars['Int']['input'];
@@ -134,6 +135,7 @@ export type Prune = 'PRUNE';
 export type PruneAction = {
     input: PruneActionInput;
     type: Prune | `${Prune}`;
+    scope: "global";
 };
 export type PruneActionInput = {
     end?: InputMaybe<Scalars['Int']['input']>;
@@ -147,11 +149,13 @@ export type Redo = 'REDO';
 export type RedoAction = {
     input: Scalars['Int']['input'];
     type: Redo | `${Redo}`;
+    scope: "global";
 };
 export type Set_Name = 'SET_NAME';
 export type SetNameAction = {
     input: Scalars['String']['input'];
     type: Set_Name | `${Set_Name}`;
+    scope: "global";
 };
 export type SetNameOperation = IOperation & {
     __typename?: 'SetNameOperation';
@@ -165,4 +169,5 @@ export type Undo = 'UNDO';
 export type UndoAction = {
     input: Scalars['Int']['input'];
     type: Undo | `${Undo}`;
+    scope: "global";
 };

package/dist/browser/document/schema/zod.d.ts

@@ -15,48 +15,63 @@ export declare function ActionSchema(): z.ZodObject<Properties<Action>>;
 export declare function BaseActionSchema(): z.ZodUnion<[z.ZodObject<Required<{
     input: z.ZodType<LoadStateActionInput, any, LoadStateActionInput>;
     type: z.ZodType<"LOAD_STATE", any, "LOAD_STATE">;
+    scope: z.ZodType<"global", any, "global">;
 }>, z.UnknownKeysParam, z.ZodTypeAny, {
     input: LoadStateActionInput;
     type: "LOAD_STATE";
+    scope: "global";
 }, {
     input: LoadStateActionInput;
     type: "LOAD_STATE";
+    scope: "global";
 }>, z.ZodObject<Required<{
     input: z.ZodType<PruneActionInput, any, PruneActionInput>;
     type: z.ZodType<"PRUNE", any, "PRUNE">;
+    scope: z.ZodType<"global", any, "global">;
 }>, z.UnknownKeysParam, z.ZodTypeAny, {
     input: PruneActionInput;
     type: "PRUNE";
+    scope: "global";
 }, {
     input: PruneActionInput;
     type: "PRUNE";
+    scope: "global";
 }>, z.ZodObject<Required<{
     input: z.ZodType<number, any, number>;
     type: z.ZodType<"REDO", any, "REDO">;
+    scope: z.ZodType<"global", any, "global">;
 }>, z.UnknownKeysParam, z.ZodTypeAny, {
     input: number;
     type: "REDO";
+    scope: "global";
 }, {
     input: number;
     type: "REDO";
+    scope: "global";
 }>, z.ZodObject<Required<{
     input: z.ZodType<string, any, string>;
     type: z.ZodType<"SET_NAME", any, "SET_NAME">;
+    scope: z.ZodType<"global", any, "global">;
 }>, z.UnknownKeysParam, z.ZodTypeAny, {
     input: string;
     type: "SET_NAME";
+    scope: "global";
 }, {
     input: string;
     type: "SET_NAME";
+    scope: "global";
 }>, z.ZodObject<Required<{
     input: z.ZodType<number, any, number>;
     type: z.ZodType<"UNDO", any, "UNDO">;
+    scope: z.ZodType<"global", any, "global">;
 }>, z.UnknownKeysParam, z.ZodTypeAny, {
     input: number;
     type: "UNDO";
+    scope: "global";
 }, {
     input: number;
     type: "UNDO";
+    scope: "global";
 }>]>;
 export declare function DocumentFileSchema(): z.ZodObject<Properties<DocumentFile>>;
 export declare function LoadStateActionSchema(): z.ZodObject<Properties<LoadStateAction>>;

package/dist/browser/document/signal.d.ts

@@ -1,3 +1,4 @@
+import { Document } from './types';
 export interface ISignal<T extends string = string, I = unknown> {
     type: T;
     input: I;
@@ -12,10 +13,10 @@ export type DeleteChildDocumentInput = {
     id: string;
 };
 export type DeleteChildDocumentSignal = ISignal<'DELETE_CHILD_DOCUMENT', DeleteChildDocumentInput>;
-export type CopyhildDocumentInput = {
+export type CopyChildDocumentInput = {
     id: string;
     newId: string;
 };
-export type CopyChildDocumentSignal = ISignal<'COPY_CHILD_DOCUMENT', CopyhildDocumentInput>;
+export type CopyChildDocumentSignal = ISignal<'COPY_CHILD_DOCUMENT', CopyChildDocumentInput>;
 export type Signal = CreateChildDocumentSignal | DeleteChildDocumentSignal | CopyChildDocumentSignal;
 export type SignalDispatch = (signal: Signal) => void;

package/dist/browser/document/types.d.ts

@@ -34,7 +34,7 @@ export type ActionWithAttachment<T extends string = string, I = unknown> = Actio
  * @typeParam State - The type of the document data.
  * @typeParam A - The type of the actions supported by the reducer.
  */
-export type Reducer<State, A extends Action> = (state: Document<State, A>, action: A | BaseAction, dispatch?: SignalDispatch) => Document<State, A>;
+export type Reducer<State, A extends Action, LocalState> = (state: Document<State, A, LocalState>, action: A | BaseAction, dispatch?: SignalDispatch) => Document<State, A, LocalState>;
 /**
  * A {@link Reducer} that prevents mutable code from changing the previous state.
  *
@@ -47,8 +47,8 @@ export type Reducer<State, A extends Action> = (state: Document<State, A>, actio
  * @typeParam State - The type of the document data.
  * @typeParam A - The type of the actions supported by the reducer.
  */
-export type ImmutableReducer<State, A extends Action> = (state: Draft<Document<State, A>>, action: A | BaseAction, dispatch?: SignalDispatch) => Document<State, A> | void;
-export type ImmutableStateReducer<State, A extends Action> = (state: Draft<State>, action: A, dispatch?: SignalDispatch) => State | void;
+export type ImmutableReducer<State, A extends Action, LocalState> = (state: Draft<Document<State, A, LocalState>>, action: A | BaseAction, dispatch?: SignalDispatch) => Document<State, A, LocalState> | void;
+export type ImmutableStateReducer<S, A extends Action, L = unknown> = (state: Draft<State<S, L>>, action: A, dispatch?: SignalDispatch) => State<S, L> | void;
 /**
  * Scope of an operation.
  * Global: The operation is synchronized everywhere in the network. This is the default document operation.
@@ -111,12 +111,21 @@ export type AttachmentInput = Attachment & {
  *
  */
 export type FileRegistry = Record<AttachmentRef, Attachment>;
-export type ExtendedState<State = unknown> = DocumentHeader & {
+export type State<GlobalState, LocalState> = {
+    global: GlobalState;
+    local: LocalState;
+};
+export type CreateState<S, L> = (state?: Partial<State<Partial<S>, Partial<L>>>) => State<S, L>;
+export type ExtendedState<GlobalState, LocalState = unknown> = DocumentHeader & {
     /** The document model specific state. */
-    state: State;
+    state: State<GlobalState, LocalState>;
     /** The index of document attachments. */
     attachments: FileRegistry;
 };
+export type DocumentOperations<A extends Action> = {
+    global: Operation<A | BaseAction>[];
+    local: Operation<A>[];
+};
 /**
  * The base type of a document model.
  *
@@ -126,13 +135,13 @@ export type ExtendedState<State = unknown> = DocumentHeader & {
  * @typeParam Data - The type of the document data attribute.
  * @typeParam A - The type of the actions supported by the Document.
  */
-export type Document<S = unknown, A extends Action = Action> = 
+export type Document<GlobalState = unknown, A extends Action = Action, LocalState = unknown> = 
 /** The document model specific state. */
-ExtendedState<S> & {
+ExtendedState<GlobalState, LocalState> & {
     /** The operations history of the document. */
-    operations: Operation<A | BaseAction>[];
+    operations: DocumentOperations<A>;
     /** The initial state of the document, enabling replaying operations. */
-    initialState: ExtendedState<S>;
+    initialState: ExtendedState<GlobalState, LocalState>;
 };
 /**
  * String type representing an attachment in a Document.
@@ -141,40 +150,40 @@ ExtendedState<S> & {
  * Attachment string is formatted as `attachment://<filename>`.
  */
 export type AttachmentRef = string;
-export interface DocumentClass<S, A extends Action = Action, C extends BaseDocument<S, A> = BaseDocument<S, A>> {
+export interface DocumentClass<S, A extends Action = Action, L = unknown, C extends BaseDocument<S, A, L> = BaseDocument<S, A, L>> {
     fileExtension: string;
     fromFile: (path: string) => Promise<C>;
-    new (initialState?: ExtendedState<S>): C;
+    new (initialState?: ExtendedState<S, L>): C;
 }
-export type DocumentModelUtils<S = unknown, A extends Action = Action> = {
+export type DocumentModelUtils<S = unknown, A extends Action = Action, L = unknown> = {
     fileExtension: string;
-    createState: (state?: Partial<S>) => S;
-    createExtendedState: (extendedState?: Partial<ExtendedState<Partial<S>>>, createState?: (state?: Partial<S>) => S) => ExtendedState<S>;
-    createDocument: (document?: Partial<ExtendedState<Partial<S>>>, createState?: (state?: Partial<S>) => S) => Document<S, A>;
-    loadFromFile: (path: string) => Promise<Document<S, A>>;
-    loadFromInput: (input: FileInput) => Promise<Document<S, A>>;
-    saveToFile: (document: Document<S, A>, path: string, name?: string) => Promise<string>;
-    saveToFileHandle: (document: Document<S, A>, input: FileSystemFileHandle) => Promise<void>;
+    createState: CreateState<S, L>;
+    createExtendedState: (extendedState?: Partial<ExtendedState<Partial<S>, Partial<L>>>, createState?: CreateState<S, L>) => ExtendedState<S, L>;
+    createDocument: (document?: Partial<ExtendedState<Partial<S>, Partial<L>>>, createState?: CreateState<S, L>) => Document<S, A, L>;
+    loadFromFile: (path: string) => Promise<Document<S, A, L>>;
+    loadFromInput: (input: FileInput) => Promise<Document<S, A, L>>;
+    saveToFile: (document: Document<S, A, L>, path: string, name?: string) => Promise<string>;
+    saveToFileHandle: (document: Document<S, A, L>, input: FileSystemFileHandle) => Promise<void>;
 };
 export type ActionCreator<A extends Action> = ((input: any) => A) | ((input: any, attachments: AttachmentInput[]) => A) | ((...input: any) => BaseAction);
-export type DocumentModel<S = unknown, A extends Action = Action, C extends BaseDocument<S, A> = BaseDocument<S, A>> = {
-    Document: DocumentClass<S, A, C>;
-    reducer: Reducer<S, A>;
+export type DocumentModel<S = unknown, A extends Action = Action, L = unknown, C extends BaseDocument<S, A, L> = BaseDocument<S, A, L>> = {
+    Document: DocumentClass<S, A, L, C>;
+    reducer: Reducer<S, A, L>;
     actions: Record<string, ActionCreator<A>>;
-    utils: DocumentModelUtils<S, A>;
+    utils: DocumentModelUtils<S, A, L>;
     documentModel: DocumentModelState;
 };
 export type EditorContext = {
     theme: 'light' | 'dark';
     debug?: boolean;
 };
-export type EditorProps<S, A extends Action> = {
-    document: Document<S, A>;
+export type EditorProps<S, A extends Action, L> = {
+    document: Document<S, A, L>;
     dispatch: (action: A | BaseAction) => void;
     editorContext: EditorContext;
 };
-export type Editor<S = unknown, A extends Action = Action> = {
-    Component: FC<EditorProps<S, A>>;
+export type Editor<S = unknown, A extends Action = Action, L = unknown> = {
+    Component: FC<EditorProps<S, A, L>>;
     documentTypes: string[];
 };
 export type DocumentModelLib = {

package/dist/browser/document/utils/base.d.ts

@@ -1,5 +1,5 @@
 import { baseReducer } from '../reducer';
-import { Action, BaseAction, Document, ExtendedState, ImmutableStateReducer, Reducer, Immutable, OperationScope } from '../types';
+import { Action, BaseAction, Document, ExtendedState, ImmutableStateReducer, Reducer, Immutable, OperationScope, State, CreateState } from '../types';
 export declare function isBaseAction(action: Action): action is BaseAction;
 /**
  * Helper function to be used by action creators.
@@ -38,8 +38,8 @@ export declare function createAction<A extends Action>(type: A['type'], input?:
  *
  * @returns The new reducer.
  */
-export declare function createReducer<S = unknown, A extends Action = Action>(reducer: ImmutableStateReducer<S, A>, documentReducer?: typeof baseReducer): Reducer<S, A>;
-export declare const createExtendedState: <S>(initialState?: Partial<ExtendedState<Partial<S>>> | undefined, createState?: ((state?: Partial<S> | undefined) => S) | undefined) => ExtendedState<S>;
+export declare function createReducer<S = unknown, A extends Action = Action, L = unknown>(reducer: ImmutableStateReducer<S, A, L>, documentReducer?: typeof baseReducer): Reducer<S, A, L>;
+export declare const createExtendedState: <S, L>(initialState?: Partial<ExtendedState<Partial<S>, Partial<L>>> | undefined, createState?: CreateState<S, L> | undefined) => ExtendedState<S, L>;
 /**
  * Builds the initial document state from the provided data.
  *
@@ -51,7 +51,7 @@ export declare const createExtendedState: <S>(initialState?: Partial<ExtendedSta
  *
  * @returns The new document state.
  */
-export declare const createDocument: <S, A extends Action>(initialState?: Partial<ExtendedState<Partial<S>>> | undefined, createState?: ((state?: Partial<S> | undefined) => S) | undefined) => Document<S, A>;
-export declare const hashDocument: (document: Document) => string;
+export declare const createDocument: <S, A extends Action, L = unknown>(initialState?: Partial<ExtendedState<Partial<S>, Partial<L>>> | undefined, createState?: ((state?: Partial<State<Partial<S>, Partial<L>>> | undefined) => State<S, L>) | undefined) => Document<S, A, L>;
+export declare const hashDocument: (document: Document, scope?: OperationScope) => string;
 export declare const hashKey: (date?: Date, randomLimit?: number) => string;
 export declare function readOnly<T>(value: T): Immutable<T>;

package/dist/browser/document/utils/file.d.ts

@@ -31,8 +31,8 @@ export declare const saveToFileHandle: (document: Document, input: FileSystemFil
  * @returns A promise that resolves to the document state after applying all the operations.
  * @throws An error if the initial state or the operations history is not found in the ZIP file.
  */
-export declare const loadFromFile: <S, A extends Action>(path: string, reducer: Reducer<S, A>) => Promise<Document<S, A>>;
-export declare const loadFromInput: <S, A extends Action>(input: FileInput, reducer: Reducer<S, A>) => Promise<Document<S, A>>;
+export declare const loadFromFile: <S, A extends Action, L>(path: string, reducer: Reducer<S, A, L>) => Promise<Document<S, A, L>>;
+export declare const loadFromInput: <S, A extends Action, L>(input: FileInput, reducer: Reducer<S, A, L>) => Promise<Document<S, A, L>>;
 /**
  * Fetches an attachment from a URL and returns its base64-encoded data and MIME type.
  * @param url - The URL of the attachment to fetch.

package/dist/browser/document-model/gen/reducer.d.ts

@@ -1,3 +1,3 @@
 import { DocumentModelState } from './schema';
 import { DocumentModelAction } from './actions';
-export declare const reducer: import("../../document/types").Reducer<DocumentModelState, DocumentModelAction>;
+export declare const reducer: import("../../document/types").Reducer<DocumentModelState, DocumentModelAction, unknown>;

package/dist/browser/document-model/gen/schema/types.d.ts

@@ -1,4 +1,4 @@
-import { OperationScope } from "../../../document";
+import { OperationScope } from '../../../document';
 export type Maybe<T> = T | null;
 export type InputMaybe<T> = T | null | undefined;
 export type Exact<T extends {
@@ -126,7 +126,10 @@ export type DocumentSpecification = {
     __typename?: 'DocumentSpecification';
     changeLog: Array<Scalars['String']['output']>;
     modules: Array<Module>;
-    state: State;
+    state: {
+        global: State;
+        local: State;
+    };
     version: Scalars['Int']['output'];
 };
 export type Module = {