document-model 1.0.0

package/dist/node/src/document/actions/creators.d.ts

@@ -0,0 +1,46 @@
+import { ExtendedState } from '../types';
+import { LoadStateAction, PruneAction, RedoAction, SetNameAction, UndoAction } from './types';
+/**
+ * Changes the name of the document.
+ *
+ * @param name - The name to be set in the document.
+ * @category Actions
+ */
+export declare const setName: (name: string) => SetNameAction;
+/**
+ * Cancels the last `count` operations.
+ *
+ * @param count - Number of operations to cancel
+ * @category Actions
+ */
+export declare const undo: (count?: number) => UndoAction;
+/**
+ * Cancels the last `count` {@link undo | UNDO} operations.
+ *
+ * @param count - Number of UNDO operations to cancel
+ * @category Actions
+ */
+export declare const redo: (count?: number) => 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
+ */
+export declare const prune: (start?: number | undefined, end?: number | undefined) => PruneAction;
+/**
+ * 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
+ */
+export declare const loadState: (state: Pick<ExtendedState, 'state' | 'name'>, operations: number) => LoadStateAction;

package/dist/node/src/document/actions/index.d.ts

@@ -0,0 +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: {
+    name: string;
+    state?: T;
+}): Document<T, A>;
+export * from './creators';

package/dist/node/src/document/actions/types.d.ts

@@ -0,0 +1,9 @@
+import { Action, BaseAction } from '../types';
+export declare const SET_NAME = "SET_NAME";
+export declare const UNDO = "UNDO";
+export declare const REDO = "REDO";
+export declare const PRUNE = "PRUNE";
+export declare const LOAD_STATE = "LOAD_STATE";
+export { LoadStateAction, PruneAction, RedoAction, SetNameAction, UndoAction, } from '../types';
+export type { BaseAction };
+export declare function isBaseAction(action: Action): action is BaseAction;

package/dist/node/src/document/index.d.ts

@@ -0,0 +1,5 @@
+export * as actions from './actions/creators';
+export * from './object';
+export * from './reducer';
+export * from './types';
+export * as utils from './utils';

package/dist/node/src/document/object.d.ts

@@ -0,0 +1,118 @@
+import { BaseAction } from './actions/types';
+import type { Action, AttachmentRef, Document, ExtendedState, Reducer } from './types';
+/**
+ * This is an abstract class representing a document and provides methods
+ * for creating and manipulating documents.
+ * @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>;
+    private _reducer;
+    /**
+     * Constructs a BaseDocument instance with an initial state.
+     * @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>);
+    /**
+     * Dispatches an action to update the state of the document.
+     * @param action - The action to dispatch.
+     * @returns The Document instance.
+     */
+    protected dispatch(action: A | BaseAction): this;
+    /**
+     * Saves the state of the document to a file.
+     * @param path - The file path where the state should be saved.
+     * @param extension - The file extension to use when saving the state.
+     * @returns The file path where the state was saved.
+     */
+    protected saveToFile(path: string, extension: string, name?: string): Promise<string>;
+    /**
+     * Loads the state of the document from a file.
+     * @param path - The file path where the state is stored.
+     */
+    loadFromFile(path: string): Promise<void>;
+    /**
+     * Loads the state of the document from a file and returns it.
+     * @param path - The file path where the state is stored.
+     * @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>>;
+    /**
+     *    Gets the current state of the document.
+     */
+    get state(): T;
+    /**
+     *    Gets the list of operations performed on the document.
+     */
+    get operations(): import("./types").Operation<BaseAction | A>[];
+    /**
+     * Gets the name of the document.
+     */
+    get name(): string;
+    /**
+     * Gets the type of document.
+     */
+    get documentType(): string;
+    /**
+     * Gets the timestamp of the date the document was created.
+     */
+    get created(): string;
+    /**
+     * Gets the timestamp of the date the document was last modified.
+     */
+    get lastModified(): string;
+    /**
+     * Gets the revision number of the document.
+     */
+    get revision(): number;
+    /**
+     * Gets the initial state of the document.
+     */
+    get initialState(): ExtendedState<T>;
+    /**
+     * Gets the attachment associated with the given key.
+     * @param attachment - The key of the attachment to retrieve.
+     */
+    getAttachment(attachment: AttachmentRef): import("./types").Attachment;
+    /**
+     * Sets the name of the document.
+     * @param name - The new name of the document.
+     */
+    setName(name: string): this;
+    /**
+     * Reverts a number of actions from the document.
+     * @param count - The number of actions to revert.
+     */
+    undo(count: number): this;
+    /**
+     * Reapplies a number of actions to the document.
+     * @param count - The number of actions to reapply.
+     */
+    redo(count: number): this;
+    /**
+     * Removes a range of operations from the document.
+     * @param start - The starting index of the range to remove.
+     * @param end - The ending index of the range to remove.
+     */
+    prune(start?: number | undefined, end?: number | undefined): this;
+    /**
+     * Loads a document state and a set of operations.
+     * @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;
+}
+/**
+ * Applies multiple mixins to a base class.
+ * Used to have separate mixins to group methods by actions.
+ *
+ * @remarks
+ * {@link https://www.typescriptlang.org/docs/handbook/mixins.html#alternative-pattern}
+ *
+ * @param derivedCtor - The class to apply the mixins to.
+ * @param constructors - The constructors of the mixins.
+ */
+export declare function applyMixins(derivedCtor: any, constructors: any[]): void;

package/dist/node/src/document/reducer.d.ts

@@ -0,0 +1,15 @@
+import { BaseAction } from './actions/types';
+import { Action, Document, ImmutableStateReducer } from './types';
+/**
+ * Base document reducer that wraps a custom document reducer and handles
+ * document-level actions such as undo, redo, prune, and set name.
+ *
+ * @template T - The type of the state of the custom reducer.
+ * @template A - The type of the actions of the custom reducer.
+ * @param state - The current state of the document.
+ * @param action - The action object to apply to the state.
+ * @param customReducer - The custom reducer that implements the application logic
+ * 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>): Document<T, A>;

package/dist/node/src/document/schema/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * as z from "./zod";

package/dist/node/src/document/schema/types.d.ts

@@ -0,0 +1,168 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = T | null | undefined;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export 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 */
+export 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}`;
+    };
+    Attachment: {
+        input: string;
+        output: string;
+    };
+    DateTime: {
+        input: string;
+        output: string;
+    };
+    Unknown: {
+        input: unknown;
+        output: unknown;
+    };
+};
+export type Action = IAction & {
+    __typename?: 'Action';
+    type: Scalars['String']['output'];
+};
+export type BaseAction = LoadStateAction | PruneAction | RedoAction | SetNameAction | UndoAction;
+export type DocumentFile = {
+    __typename?: 'DocumentFile';
+    data: Scalars['String']['output'];
+    extension: Maybe<Scalars['String']['output']>;
+    fileName: Maybe<Scalars['String']['output']>;
+    mimeType: Scalars['String']['output'];
+};
+export type IAction = {
+    type: Scalars['String']['output'];
+};
+export 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'];
+};
+export type IOperation = {
+    hash: Scalars['String']['output'];
+    index: Scalars['Int']['output'];
+    timestamp: Scalars['DateTime']['output'];
+    type: Scalars['String']['output'];
+};
+export type Load_State = 'LOAD_STATE';
+export type LoadStateAction = {
+    input: LoadStateActionInput;
+    type: Load_State | `${Load_State}`;
+};
+export type LoadStateActionInput = {
+    operations: Scalars['Int']['input'];
+    state: LoadStateActionStateInput;
+};
+export type LoadStateActionStateInput = {
+    data?: InputMaybe<Scalars['Unknown']['input']>;
+    name: Scalars['String']['input'];
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    loadState: Maybe<IDocument>;
+    prune: Maybe<IDocument>;
+    redo: Maybe<IDocument>;
+    setName: Maybe<IDocument>;
+    undo: Maybe<IDocument>;
+};
+export type MutationLoadStateArgs = {
+    input: LoadStateAction;
+};
+export type MutationPruneArgs = {
+    input: PruneAction;
+};
+export type MutationRedoArgs = {
+    input: RedoAction;
+};
+export type MutationSetNameArgs = {
+    input: SetNameAction;
+};
+export type MutationUndoArgs = {
+    input: UndoAction;
+};
+export type Operation = IOperation & {
+    __typename?: 'Operation';
+    hash: Scalars['String']['output'];
+    index: Scalars['Int']['output'];
+    timestamp: Scalars['DateTime']['output'];
+    type: Scalars['String']['output'];
+};
+export type Prune = 'PRUNE';
+export type PruneAction = {
+    input: PruneActionInput;
+    type: Prune | `${Prune}`;
+};
+export type PruneActionInput = {
+    end?: InputMaybe<Scalars['Int']['input']>;
+    start?: InputMaybe<Scalars['Int']['input']>;
+};
+export type Query = {
+    __typename?: 'Query';
+    document: Maybe<IDocument>;
+};
+export type Redo = 'REDO';
+export type RedoAction = {
+    input: Scalars['Int']['input'];
+    type: Redo | `${Redo}`;
+};
+export type Set_Name = 'SET_NAME';
+export type SetNameAction = {
+    input: Scalars['String']['input'];
+    type: Set_Name | `${Set_Name}`;
+};
+export 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'];
+};
+export type Undo = 'UNDO';
+export type UndoAction = {
+    input: Scalars['Int']['input'];
+    type: Undo | `${Undo}`;
+};

package/dist/node/src/document/schema/zod.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { Action, DocumentFile, LoadStateAction, LoadStateActionInput, LoadStateActionStateInput, Operation, PruneAction, PruneActionInput, RedoAction, SetNameAction, SetNameOperation, UndoAction } from '.';
+type Properties<T> = Required<{
+    [K in keyof T]: z.ZodType<T[K], any, T[K]>;
+}>;
+type definedNonNullAny = {};
+export declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
+export declare const definedNonNullAnySchema: z.ZodEffects<z.ZodAny, any, any>;
+export declare const Load_StateSchema: z.ZodEnum<["LOAD_STATE"]>;
+export declare const PruneSchema: z.ZodEnum<["PRUNE"]>;
+export declare const RedoSchema: z.ZodEnum<["REDO"]>;
+export declare const Set_NameSchema: z.ZodEnum<["SET_NAME"]>;
+export declare const UndoSchema: z.ZodEnum<["UNDO"]>;
+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">;
+}>, z.UnknownKeysParam, z.ZodTypeAny, {
+    input: LoadStateActionInput;
+    type: "LOAD_STATE";
+}, {
+    input: LoadStateActionInput;
+    type: "LOAD_STATE";
+}>, z.ZodObject<Required<{
+    input: z.ZodType<PruneActionInput, any, PruneActionInput>;
+    type: z.ZodType<"PRUNE", any, "PRUNE">;
+}>, z.UnknownKeysParam, z.ZodTypeAny, {
+    input: PruneActionInput;
+    type: "PRUNE";
+}, {
+    input: PruneActionInput;
+    type: "PRUNE";
+}>, z.ZodObject<Required<{
+    input: z.ZodType<number, any, number>;
+    type: z.ZodType<"REDO", any, "REDO">;
+}>, z.UnknownKeysParam, z.ZodTypeAny, {
+    input: number;
+    type: "REDO";
+}, {
+    input: number;
+    type: "REDO";
+}>, z.ZodObject<Required<{
+    input: z.ZodType<string, any, string>;
+    type: z.ZodType<"SET_NAME", any, "SET_NAME">;
+}>, z.UnknownKeysParam, z.ZodTypeAny, {
+    input: string;
+    type: "SET_NAME";
+}, {
+    input: string;
+    type: "SET_NAME";
+}>, z.ZodObject<Required<{
+    input: z.ZodType<number, any, number>;
+    type: z.ZodType<"UNDO", any, "UNDO">;
+}>, z.UnknownKeysParam, z.ZodTypeAny, {
+    input: number;
+    type: "UNDO";
+}, {
+    input: number;
+    type: "UNDO";
+}>]>;
+export declare function DocumentFileSchema(): z.ZodObject<Properties<DocumentFile>>;
+export declare function LoadStateActionSchema(): z.ZodObject<Properties<LoadStateAction>>;
+export declare function LoadStateActionInputSchema(): z.ZodObject<Properties<LoadStateActionInput>>;
+export declare function LoadStateActionStateInputSchema(): z.ZodObject<Properties<LoadStateActionStateInput>>;
+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 function RedoActionSchema(): z.ZodObject<Properties<RedoAction>>;
+export declare function SetNameActionSchema(): z.ZodObject<Properties<SetNameAction>>;
+export declare function SetNameOperationSchema(): z.ZodObject<Properties<SetNameOperation>>;
+export declare function UndoActionSchema(): z.ZodObject<Properties<UndoAction>>;
+export {};

package/dist/node/src/document/types.d.ts

@@ -0,0 +1,154 @@
+import type { Draft } from 'immer';
+import type { DocumentModelState } from '../document-model';
+import type { BaseAction } from './actions/types';
+import { BaseDocument } from './object';
+import { FileInput } from './utils';
+export { z } from './schema';
+export type * from './schema/types';
+/**
+ * Defines the basic structure of an action.
+ *
+ * @typeParam T - The name of the action type. A `string` type by default.
+ */
+export type Action<T extends string = string, I = unknown> = {
+    /** The name of the action. */
+    type: T;
+    /** The payload of the action. */
+    input: I;
+    /** The attachments included in the action. */
+    attachments?: AttachmentInput[] | undefined;
+};
+export type ActionWithAttachment<T extends string = string, I = unknown> = Action<T, I> & {
+    attachments: AttachmentInput[];
+};
+/**
+ * A pure function that takes an action and the previous state
+ * of the document and returns the new state.
+ *
+ * @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) => Document<State, A>;
+/**
+ * A {@link Reducer} that prevents mutable code from changing the previous state.
+ *
+ * @remarks
+ * This reducer is wrapped with {@link https://immerjs.github.io/immer/ | Immer}.
+ * This allows the reducer code to be mutable, making it simpler and
+ * avoiding unintended changes in the provided state.
+ * The returned state will always be a new object.
+ *
+ * @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) => Document<State, A> | void;
+export type ImmutableStateReducer<State, A extends Action> = (state: Draft<State>, action: A) => State | void;
+/**
+ * An operation that was applied to a {@link Document}.
+ *
+ * @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.
+ *
+ * @typeParam A - The type of the action.
+ */
+export type Operation<A extends Action = Action> = A & {
+    /** Position of the operation in the history */
+    index: number;
+    /** Timestamp of when the operation was added */
+    timestamp: string;
+    /** Hash of the resulting document data after the operation */
+    hash: string;
+};
+/**
+ * The base attributes of a {@link Document}.
+ */
+export type DocumentHeader = {
+    /** The name of the document. */
+    name: string;
+    /** The number of operations applied to the document. */
+    revision: number;
+    /** The type of the document model. */
+    documentType: string;
+    /** The timestamp of the creation date of the document. */
+    created: string;
+    /** The timestamp of the last change in the document. */
+    lastModified: string;
+};
+/**
+ * The attributes stored for a file. Namely, attachments of a document.
+ */
+export type Attachment = {
+    /** The binary data of the attachment in Base64 */
+    data: string;
+    /** The MIME type of the attachment */
+    mimeType: string;
+    extension?: string | null;
+    fileName?: string | null;
+};
+export type AttachmentInput = Attachment & {
+    hash: string;
+};
+/**
+ * Object that indexes attachments of a Document.
+ *
+ * @remarks
+ * This is used to reduce memory usage to avoid
+ * multiple instances of the binary data of the attachments.
+ *
+ */
+export type FileRegistry = Record<AttachmentRef, Attachment>;
+export type ExtendedState<State = unknown> = DocumentHeader & {
+    /** The document model specific state. */
+    state: State;
+    /** The index of document attachments. */
+    attachments: FileRegistry;
+};
+/**
+ * The base type of a document model.
+ *
+ * @remarks
+ * This type is extended by all Document models.
+ *
+ * @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> = 
+/** The document model specific state. */
+ExtendedState<S> & {
+    /** The operations history of the document. */
+    operations: Operation<A | BaseAction>[];
+    /** The initial state of the document, enabling replaying operations. */
+    initialState: ExtendedState<S>;
+};
+/**
+ * String type representing an attachment in a Document.
+ *
+ * @remarks
+ * 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>> {
+    fileExtension: string;
+    fromFile: (path: string) => Promise<C>;
+    new (initialState?: ExtendedState<S>): C;
+}
+export type DocumentModelUtils<S = unknown, A extends Action = Action> = {
+    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>;
+};
+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>;
+    actions: Record<string, ActionCreator<A>>;
+    utils: DocumentModelUtils<S, A>;
+    documentModel: DocumentModelState;
+};

package/dist/node/src/document/utils/base.d.ts

@@ -0,0 +1,55 @@
+import { baseReducer } from '../reducer';
+import { Action, Document, ExtendedState, ImmutableStateReducer, Reducer } from '../types';
+/**
+ * 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.
+ *
+ * @throws Error if the type is empty or not a string.
+ *
+ * @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;
+}): A;
+/**
+ * Helper function to create a document model reducer.
+ *
+ * @remarks
+ * This function creates a new reducer that wraps the provided `reducer` with
+ * `documentReducer`, adding support for document actions:
+ *   - `SET_NAME`
+ *   - `UNDO`
+ *   - `REDO`
+ *   - `PRUNE`
+ *
+ * It also updates the document-related attributes on every operation.
+ *
+ * @param reducer - The custom reducer to wrap.
+ * @param documentReducer - The document reducer to use.
+ *
+ * @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>;
+/**
+ * Builds the initial document state from the provided data.
+ *
+ * @typeParam T - The type of the data.
+ * @typeParam A - The type of the actions.
+ *
+ * @param initialState - The initial state of the document. The `data` property
+ *   is required, but all other properties are optional.
+ *
+ * @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 hashKey: (date?: Date, randomLimit?: number) => string;