document-model 1.0.15 → 1.0.17

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>>;
@@ -65,8 +80,32 @@ export declare function LoadStateActionStateInputSchema(): z.ZodObject<Propertie
 export declare function OperationSchema(): z.ZodObject<Properties<Operation>>;
 export declare function PruneActionSchema(): z.ZodObject<Properties<PruneAction>>;
 export declare function PruneActionInputSchema(): z.ZodObject<Properties<PruneActionInput>>;
+export declare const RedoActionInputSchema: (params?: ({
+    errorMap?: z.ZodErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    description?: string | undefined;
+} & {
+    coerce?: boolean | undefined;
+}) | undefined) => z.ZodNumber;
 export declare function RedoActionSchema(): z.ZodObject<Properties<RedoAction>>;
+export declare const SetNameActionInputSchema: (params?: ({
+    errorMap?: z.ZodErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    description?: string | undefined;
+} & {
+    coerce?: true | undefined;
+}) | undefined) => z.ZodString;
 export declare function SetNameActionSchema(): z.ZodObject<Properties<SetNameAction>>;
 export declare function SetNameOperationSchema(): z.ZodObject<Properties<SetNameOperation>>;
+export declare const UndoActionInputSchema: (params?: ({
+    errorMap?: z.ZodErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    description?: string | undefined;
+} & {
+    coerce?: boolean | undefined;
+}) | undefined) => z.ZodNumber;
 export declare function UndoActionSchema(): z.ZodObject<Properties<UndoAction>>;
 export {};

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

@@ -14,17 +14,17 @@ export type { Immutable } from 'immer';
  *
  * @typeParam T - The name of the action type. A `string` type by default.
  */
-export type Action<T extends string = string, I = unknown> = {
+export type Action<T extends string = string, I = unknown, S extends OperationScope = OperationScope> = {
     /** The name of the action. */
     type: T;
     /** The payload of the action. */
     input: I;
+    /** The scope of the action, can either be 'global' or 'local' */
+    scope: S;
     /** The attachments included in the action. */
     attachments?: AttachmentInput[] | undefined;
-    /** The scope of the action, can either be 'global' or 'local'. Defaults to 'global' */
-    scope?: OperationScope;
 };
-export type ActionWithAttachment<T extends string = string, I = unknown> = Action<T, I> & {
+export type ActionWithAttachment<T extends string = string, I = unknown, S extends OperationScope = OperationScope> = Action<T, I, S> & {
     attachments: AttachmentInput[];
 };
 /**
@@ -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,22 @@ 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 PartialState<S> = S | Partial<S>;
+export type CreateState<S, L> = (state?: Partial<State<PartialState<S>, PartialState<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 +136,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 +151,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<PartialState<S>, PartialState<L>>>, createState?: CreateState<S, L>) => ExtendedState<S, L>;
+    createDocument: (document?: Partial<ExtendedState<PartialState<S>, PartialState<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, PartialState } from '../types';
 export declare function isBaseAction(action: Action): action is BaseAction;
 /**
  * Helper function to be used by action creators.
@@ -18,7 +18,7 @@ export declare function isBaseAction(action: Action): action is BaseAction;
  * @returns The new action.
  */
 export declare function createAction<A extends Action>(type: A['type'], input?: A['input'], attachments?: Action['attachments'], validator?: () => {
-    parse(v: unknown): A;
+    parse(v: unknown): A['input'];
 }, scope?: OperationScope): A;
 /**
  * Helper function to create a document model reducer.
@@ -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<PartialState<S>, PartialState<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<PartialState<S>, PartialState<L>>> | undefined, createState?: ((state?: Partial<State<PartialState<S>, PartialState<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>;