document-model 1.0.21 → 1.0.22

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

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+import { Action, DocumentFile, LoadStateAction, LoadStateActionInput, LoadStateActionStateInput, Operation, PruneAction, PruneActionInput, RedoAction, SetNameAction, SetNameOperation, UndoAction } from '.';
+import { OperationScope } from '../types';
+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 OperationScopeSchema(): z.ZodType<OperationScope>;
+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<OperationScope, any, OperationScope>;
+}>, z.UnknownKeysParam, z.ZodTypeAny, {
+    input: LoadStateActionInput;
+    type: "LOAD_STATE";
+    scope: "global" | "local";
+}, {
+    input: LoadStateActionInput;
+    type: "LOAD_STATE";
+    scope: "global" | "local";
+}>, z.ZodObject<Required<{
+    input: z.ZodType<PruneActionInput, any, PruneActionInput>;
+    type: z.ZodType<"PRUNE", any, "PRUNE">;
+    scope: z.ZodType<OperationScope, any, OperationScope>;
+}>, z.UnknownKeysParam, z.ZodTypeAny, {
+    input: PruneActionInput;
+    type: "PRUNE";
+    scope: "global" | "local";
+}, {
+    input: PruneActionInput;
+    type: "PRUNE";
+    scope: "global" | "local";
+}>, z.ZodObject<Required<{
+    input: z.ZodType<number, any, number>;
+    type: z.ZodType<"REDO", any, "REDO">;
+    scope: z.ZodType<OperationScope, any, OperationScope>;
+}>, z.UnknownKeysParam, z.ZodTypeAny, {
+    input: number;
+    type: "REDO";
+    scope: "global" | "local";
+}, {
+    input: number;
+    type: "REDO";
+    scope: "global" | "local";
+}>, 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<OperationScope, any, OperationScope>;
+}>, z.UnknownKeysParam, z.ZodTypeAny, {
+    input: number;
+    type: "UNDO";
+    scope: "global" | "local";
+}, {
+    input: number;
+    type: "UNDO";
+    scope: "global" | "local";
+}>]>;
+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 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/src/document/signal.d.ts

@@ -0,0 +1,22 @@
+import { Document } from './types';
+export interface ISignal<T extends string = string, I = unknown> {
+    type: T;
+    input: I;
+}
+export type CreateChildDocumentInput = {
+    id: string;
+    documentType: string;
+    document?: Document;
+};
+export type CreateChildDocumentSignal = ISignal<'CREATE_CHILD_DOCUMENT', CreateChildDocumentInput>;
+export type DeleteChildDocumentInput = {
+    id: string;
+};
+export type DeleteChildDocumentSignal = ISignal<'DELETE_CHILD_DOCUMENT', DeleteChildDocumentInput>;
+export type CopyChildDocumentInput = {
+    id: string;
+    newId: string;
+};
+export type CopyChildDocumentSignal = ISignal<'COPY_CHILD_DOCUMENT', CopyChildDocumentInput>;
+export type Signal = CreateChildDocumentSignal | DeleteChildDocumentSignal | CopyChildDocumentSignal;
+export type SignalDispatch = (signal: Signal) => void;

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

@@ -0,0 +1,190 @@
+import type { Draft } from 'immer';
+import type { FC } from 'react';
+import type { DocumentModelState } from '../document-model/';
+import type { BaseAction } from './actions/types';
+import { BaseDocument } from './object';
+import { FileInput } from './utils';
+import { SignalDispatch } from './signal';
+export { z } from './schema';
+export type * from './schema/types';
+export type { FileInput } from './utils';
+export type { Immutable } from 'immer';
+/**
+ * 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, 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;
+};
+export type ActionWithAttachment<T extends string = string, I = unknown, S extends OperationScope = OperationScope> = Action<T, I, S> & {
+    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, 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.
+ *
+ * @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, LocalState> = (state: Draft<Document<State, A, LocalState>>, action: A | BaseAction, dispatch?: SignalDispatch) => Document<State, A, LocalState> | undefined;
+export type ImmutableStateReducer<S, A extends Action, L = unknown> = (state: Draft<State<S, L>>, action: A, dispatch?: SignalDispatch) => State<S, L> | undefined;
+/**
+ * Scope of an operation.
+ * Global: The operation is synchronized everywhere in the network. This is the default document operation.
+ * Local: The operation is applied only locally (to a local state). Used for local settings such as a drive's local path
+ */
+export type OperationScope = 'global' | 'local';
+/**
+ * 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: Required<Record<OperationScope, 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 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<GlobalState, LocalState>;
+    /** The index of document attachments. */
+    attachments: FileRegistry;
+};
+export type DocumentOperations<A extends Action> = Required<Record<OperationScope, Operation<A | BaseAction>[]>>;
+/**
+ * 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<GlobalState = unknown, A extends Action = Action, LocalState = unknown> = 
+/** The document model specific state. */
+ExtendedState<GlobalState, LocalState> & {
+    /** The operations history of the document. */
+    operations: DocumentOperations<A>;
+    /** The initial state of the document, enabling replaying operations. */
+    initialState: ExtendedState<GlobalState, LocalState>;
+};
+/**
+ * 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, L = unknown, C extends BaseDocument<S, A, L> = BaseDocument<S, A, L>> {
+    fileExtension: string;
+    fromFile: (path: string) => Promise<C>;
+    new (initialState?: ExtendedState<S, L>): C;
+}
+export type DocumentModelUtils<S = unknown, A extends Action = Action, L = unknown> = {
+    fileExtension: string;
+    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, 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, L>;
+    documentModel: DocumentModelState;
+};
+export type EditorContext = {
+    theme: 'light' | 'dark';
+    debug?: boolean;
+};
+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, L = unknown> = {
+    Component: FC<EditorProps<S, A, L>>;
+    documentTypes: string[];
+};
+export type DocumentModelLib = {
+    documentModels: DocumentModel[];
+    editors: Editor[];
+};

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

@@ -0,0 +1,61 @@
+import { baseReducer } from '../reducer';
+import { Action, BaseAction, Document, ExtendedState, ImmutableStateReducer, Reducer, Immutable, OperationScope, State, CreateState, PartialState, DocumentOperations, DocumentHeader } from '../types';
+import { SignalDispatch } from '../signal';
+export declare function isBaseAction(action: Action): action is BaseAction;
+/**
+ * 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['input'];
+}, scope?: OperationScope): 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, 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.
+ *
+ * @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, 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: Pick<Document, 'state'>, scope?: OperationScope) => string;
+export declare const hashKey: (date?: Date, randomLimit?: number) => string;
+export declare function readOnly<T>(value: T): Immutable<T>;
+export declare function sortOperations<A extends Action>(operations: DocumentOperations<A>): import("../types").Operation<BaseAction | A>[];
+export declare function replayOperations<T, A extends Action, L>(initialState: ExtendedState<T, L>, operations: DocumentOperations<A>, reducer: ImmutableStateReducer<T, A, L>, dispatch?: SignalDispatch, header?: DocumentHeader, documentReducer?: typeof baseReducer): Document<T, A, L>;
+export declare function replayDocument<T, A extends Action, L>(initialState: ExtendedState<T, L>, operations: DocumentOperations<A>, reducer: Reducer<T, A, L>, dispatch?: SignalDispatch, header?: DocumentHeader): Document<T, A, L>;

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

@@ -0,0 +1,47 @@
+import JSZip from 'jszip';
+import type { Action, AttachmentInput, Document, Reducer } from '../types';
+export type FileInput = string | number[] | Uint8Array | ArrayBuffer | Blob;
+export declare const createZip: (document: Document) => Promise<JSZip>;
+/**
+ * Saves a document to a ZIP file.
+ *
+ * @remarks
+ * This function creates a ZIP file containing the document's state, operations,
+ * and file attachments. The file is saved to the specified path.
+ *
+ * @param document - The document to save to the file.
+ * @param path - The path to save the file to.
+ * @param extension - The extension to use for the file.
+ * @returns A promise that resolves to the path of the saved file.
+ */
+export declare const saveToFile: (document: Document, path: string, extension: string, name?: string) => Promise<string>;
+export declare const saveToFileHandle: (document: Document, input: FileSystemFileHandle) => Promise<void>;
+/**
+ * Loads a document from a ZIP file.
+ *
+ * @remarks
+ * This function reads a ZIP file and returns the document state after
+ * applying all the operations. The reducer is used to apply the operations.
+ *
+ * @typeParam S - The type of the state object.
+ * @typeParam A - The type of the actions that can be applied to the state object.
+ *
+ * @param path - The path to the ZIP file.
+ * @param reducer - The reducer to apply the operations to the state object.
+ * @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, 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.
+ * @returns A Promise that resolves to an object containing the base64-encoded data and MIME type of the attachment.
+ */
+export declare function getRemoteFile(url: string): Promise<AttachmentInput>;
+/**
+ * Reads an attachment from a file and returns its base64-encoded data and MIME type.
+ * @param path - The path of the attachment file to read.
+ * @returns A Promise that resolves to an object containing the base64-encoded data and MIME type of the attachment.
+ */
+export declare function getLocalFile(path: string): Promise<AttachmentInput>;

package/dist/browser/src/document/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base';
+export * from './file';

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export declare function writeFile(path: string, name: string, data: Uint8Array): Promise<string>;
+export declare function readFile(path: string): Buffer;
+export declare function fetchFile(url: string): Promise<{
+    buffer: Buffer;
+    mimeType?: string;
+}>;
+export declare const getFile: (file: string) => Promise<Buffer>;
+export declare const hash: (data: string, algorithm?: string) => string;

package/dist/browser/src/document-model/custom/reducers/header.d.ts

@@ -0,0 +1,2 @@
+import { DocumentModelHeaderOperations } from '../../gen/header/operations';
+export declare const reducer: DocumentModelHeaderOperations;

package/dist/browser/src/document-model/custom/reducers/module.d.ts

@@ -0,0 +1,2 @@
+import { DocumentModelModuleOperations } from '../../gen/module/operations';
+export declare const reducer: DocumentModelModuleOperations;

package/dist/browser/src/document-model/custom/reducers/operation-error.d.ts

@@ -0,0 +1,2 @@
+import { DocumentModelOperationErrorOperations } from '../../gen/operation-error/operations';
+export declare const reducer: DocumentModelOperationErrorOperations;

package/dist/browser/src/document-model/custom/reducers/operation-example.d.ts

@@ -0,0 +1,2 @@
+import { DocumentModelOperationExampleOperations } from '../../gen/operation-example/operations';
+export declare const reducer: DocumentModelOperationExampleOperations;

package/dist/browser/src/document-model/custom/reducers/operation.d.ts

@@ -0,0 +1,2 @@
+import { DocumentModelOperationOperations } from '../../gen/operation/operations';
+export declare const reducer: DocumentModelOperationOperations;

package/dist/browser/src/document-model/custom/reducers/state.d.ts

@@ -0,0 +1,2 @@
+import { DocumentModelStateOperations } from '../../gen/state/operations';
+export declare const reducer: DocumentModelStateOperations;

package/dist/browser/src/document-model/custom/reducers/versioning.d.ts

@@ -0,0 +1,7 @@
+/**
+* This is a scaffold file meant for customization:
+* - modify it by implementing the reducer functions
+* - delete the file and run the code generator again to have it reset
+*/
+import { DocumentModelVersioningOperations } from '../../gen/versioning/operations';
+export declare const reducer: DocumentModelVersioningOperations;

package/dist/browser/src/document-model/custom/utils.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/browser/src/document-model/gen/actions.d.ts

@@ -0,0 +1,15 @@
+import { DocumentModelHeaderAction } from './header/actions';
+import { DocumentModelVersioningAction } from './versioning/actions';
+import { DocumentModelModuleAction } from './module/actions';
+import { DocumentModelOperationErrorAction } from './operation-error/actions';
+import { DocumentModelOperationExampleAction } from './operation-example/actions';
+import { DocumentModelOperationAction } from './operation/actions';
+import { DocumentModelStateAction } from './state/actions';
+export * from './header/actions';
+export * from './versioning/actions';
+export * from './module/actions';
+export * from './operation-error/actions';
+export * from './operation-example/actions';
+export * from './operation/actions';
+export * from './state/actions';
+export type DocumentModelAction = DocumentModelHeaderAction | DocumentModelVersioningAction | DocumentModelModuleAction | DocumentModelOperationErrorAction | DocumentModelOperationExampleAction | DocumentModelOperationAction | DocumentModelStateAction;

package/dist/browser/src/document-model/gen/creators.d.ts

@@ -0,0 +1,7 @@
+export * from './header/creators';
+export * from './versioning/creators';
+export * from './module/creators';
+export * from './operation-error/creators';
+export * from './operation-example/creators';
+export * from './operation/creators';
+export * from './state/creators';

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

@@ -0,0 +1,2 @@
+import type { DocumentModelState } from '..';
+export declare const documentModel: DocumentModelState;

package/dist/browser/src/document-model/gen/header/actions.d.ts

@@ -0,0 +1,9 @@
+import { Action } from '../../../document';
+import { SetModelNameInput, SetModelIdInput, SetModelExtensionInput, SetModelDescriptionInput, SetAuthorNameInput, SetAuthorWebsiteInput } from '../types';
+export type SetModelNameAction = Action<'SET_MODEL_NAME', SetModelNameInput>;
+export type SetModelIdAction = Action<'SET_MODEL_ID', SetModelIdInput>;
+export type SetModelExtensionAction = Action<'SET_MODEL_EXTENSION', SetModelExtensionInput>;
+export type SetModelDescriptionAction = Action<'SET_MODEL_DESCRIPTION', SetModelDescriptionInput>;
+export type SetAuthorNameAction = Action<'SET_AUTHOR_NAME', SetAuthorNameInput>;
+export type SetAuthorWebsiteAction = Action<'SET_AUTHOR_WEBSITE', SetAuthorWebsiteInput>;
+export type DocumentModelHeaderAction = SetModelNameAction | SetModelIdAction | SetModelExtensionAction | SetModelDescriptionAction | SetAuthorNameAction | SetAuthorWebsiteAction;

package/dist/browser/src/document-model/gen/header/creators.d.ts

@@ -0,0 +1,8 @@
+import { SetModelNameInput, SetModelIdInput, SetModelExtensionInput, SetModelDescriptionInput, SetAuthorNameInput, SetAuthorWebsiteInput } from '../types';
+import { SetModelNameAction, SetModelIdAction, SetModelExtensionAction, SetModelDescriptionAction, SetAuthorNameAction, SetAuthorWebsiteAction } from './actions';
+export declare const setModelName: (input: SetModelNameInput) => SetModelNameAction;
+export declare const setModelId: (input: SetModelIdInput) => SetModelIdAction;
+export declare const setModelExtension: (input: SetModelExtensionInput) => SetModelExtensionAction;
+export declare const setModelDescription: (input: SetModelDescriptionInput) => SetModelDescriptionAction;
+export declare const setAuthorName: (input: SetAuthorNameInput) => SetAuthorNameAction;
+export declare const setAuthorWebsite: (input: SetAuthorWebsiteInput) => SetAuthorWebsiteAction;

package/dist/browser/src/document-model/gen/header/object.d.ts

@@ -0,0 +1,11 @@
+import { BaseDocument } from '../../../document/object';
+import { SetModelNameInput, SetModelIdInput, SetModelExtensionInput, SetModelDescriptionInput, SetAuthorNameInput, SetAuthorWebsiteInput, DocumentModelState, DocumentModelLocalState } from '../types';
+import { DocumentModelAction } from '../actions';
+export default class DocumentModel_Header extends BaseDocument<DocumentModelState, DocumentModelAction, DocumentModelLocalState> {
+    setModelName(input: SetModelNameInput): this;
+    setModelId(input: SetModelIdInput): this;
+    setModelExtension(input: SetModelExtensionInput): this;
+    setModelDescription(input: SetModelDescriptionInput): this;
+    setAuthorName(input: SetAuthorNameInput): this;
+    setAuthorWebsite(input: SetAuthorWebsiteInput): this;
+}

package/dist/browser/src/document-model/gen/header/operations.d.ts

@@ -0,0 +1,10 @@
+import { SetModelNameAction, SetModelIdAction, SetModelExtensionAction, SetModelDescriptionAction, SetAuthorNameAction, SetAuthorWebsiteAction } from './actions';
+import { DocumentModelState } from '../types';
+export interface DocumentModelHeaderOperations {
+    setModelNameOperation: (state: DocumentModelState, action: SetModelNameAction) => void;
+    setModelIdOperation: (state: DocumentModelState, action: SetModelIdAction) => void;
+    setModelExtensionOperation: (state: DocumentModelState, action: SetModelExtensionAction) => void;
+    setModelDescriptionOperation: (state: DocumentModelState, action: SetModelDescriptionAction) => void;
+    setAuthorNameOperation: (state: DocumentModelState, action: SetAuthorNameAction) => void;
+    setAuthorWebsiteOperation: (state: DocumentModelState, action: SetAuthorWebsiteAction) => void;
+}

package/dist/browser/src/document-model/gen/index.d.ts

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

package/dist/browser/src/document-model/gen/module/actions.d.ts

@@ -0,0 +1,8 @@
+import { Action } from '../../../document';
+import { AddModuleInput, SetModuleNameInput, SetModuleDescriptionInput, DeleteModuleInput, ReorderModulesInput } from '../types';
+export type AddModuleAction = Action<'ADD_MODULE', AddModuleInput>;
+export type SetModuleNameAction = Action<'SET_MODULE_NAME', SetModuleNameInput>;
+export type SetModuleDescriptionAction = Action<'SET_MODULE_DESCRIPTION', SetModuleDescriptionInput>;
+export type DeleteModuleAction = Action<'DELETE_MODULE', DeleteModuleInput>;
+export type ReorderModulesAction = Action<'REORDER_MODULES', ReorderModulesInput>;
+export type DocumentModelModuleAction = AddModuleAction | SetModuleNameAction | SetModuleDescriptionAction | DeleteModuleAction | ReorderModulesAction;

package/dist/browser/src/document-model/gen/module/creators.d.ts

@@ -0,0 +1,7 @@
+import { AddModuleInput, SetModuleNameInput, SetModuleDescriptionInput, DeleteModuleInput, ReorderModulesInput } from '../types';
+import { AddModuleAction, SetModuleNameAction, SetModuleDescriptionAction, DeleteModuleAction, ReorderModulesAction } from './actions';
+export declare const addModule: (input: AddModuleInput) => AddModuleAction;
+export declare const setModuleName: (input: SetModuleNameInput) => SetModuleNameAction;
+export declare const setModuleDescription: (input: SetModuleDescriptionInput) => SetModuleDescriptionAction;
+export declare const deleteModule: (input: DeleteModuleInput) => DeleteModuleAction;
+export declare const reorderModules: (input: ReorderModulesInput) => ReorderModulesAction;

package/dist/browser/src/document-model/gen/module/object.d.ts

@@ -0,0 +1,10 @@
+import { BaseDocument } from '../../../document/object';
+import { AddModuleInput, SetModuleNameInput, SetModuleDescriptionInput, DeleteModuleInput, ReorderModulesInput, DocumentModelState, DocumentModelLocalState } from '../types';
+import { DocumentModelAction } from '../actions';
+export default class DocumentModel_Module extends BaseDocument<DocumentModelState, DocumentModelAction, DocumentModelLocalState> {
+    addModule(input: AddModuleInput): this;
+    setModuleName(input: SetModuleNameInput): this;
+    setModuleDescription(input: SetModuleDescriptionInput): this;
+    deleteModule(input: DeleteModuleInput): this;
+    reorderModules(input: ReorderModulesInput): this;
+}

package/dist/browser/src/document-model/gen/module/operations.d.ts

@@ -0,0 +1,9 @@
+import { AddModuleAction, SetModuleNameAction, SetModuleDescriptionAction, DeleteModuleAction, ReorderModulesAction } from './actions';
+import { DocumentModelState } from '../types';
+export interface DocumentModelModuleOperations {
+    addModuleOperation: (state: DocumentModelState, action: AddModuleAction) => void;
+    setModuleNameOperation: (state: DocumentModelState, action: SetModuleNameAction) => void;
+    setModuleDescriptionOperation: (state: DocumentModelState, action: SetModuleDescriptionAction) => void;
+    deleteModuleOperation: (state: DocumentModelState, action: DeleteModuleAction) => void;
+    reorderModulesOperation: (state: DocumentModelState, action: ReorderModulesAction) => void;
+}

package/dist/browser/src/document-model/gen/object.d.ts

@@ -0,0 +1,28 @@
+import { DocumentModelLocalState, DocumentModelState } from './types';
+import { ExtendedState, PartialState, SignalDispatch } from '../../document';
+import { BaseDocument } from '../../document/object';
+import { DocumentModelAction } from './actions';
+import DocumentModel_Header from './header/object';
+import DocumentModel_Versioning from './versioning/object';
+import DocumentModel_Module from './module/object';
+import DocumentModel_OperationError from './operation-error/object';
+import DocumentModel_OperationExample from './operation-example/object';
+import DocumentModel_Operation from './operation/object';
+import DocumentModel_State from './state/object';
+export * from './header/object';
+export * from './versioning/object';
+export * from './module/object';
+export * from './operation-error/object';
+export * from './operation-example/object';
+export * from './operation/object';
+export * from './state/object';
+interface DocumentModel extends DocumentModel_Header, DocumentModel_Versioning, DocumentModel_Module, DocumentModel_OperationError, DocumentModel_OperationExample, DocumentModel_Operation, DocumentModel_State {
+}
+declare class DocumentModel extends BaseDocument<DocumentModelState, DocumentModelAction, DocumentModelLocalState> {
+    static fileExtension: string;
+    constructor(initialState?: Partial<ExtendedState<PartialState<DocumentModelState>, PartialState<DocumentModelLocalState>>>, dispatch?: SignalDispatch);
+    saveToFile(path: string, name?: string): Promise<string>;
+    loadFromFile(path: string): Promise<void>;
+    static fromFile(path: string): Promise<DocumentModel>;
+}
+export { DocumentModel };