document-model 2.4.1 → 2.5.0-test.0

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

@@ -1,176 +0,0 @@
-import { OperationScope } from '..';
-export type Maybe<T> = T | null;
-export type InputMaybe<T> = T | null | undefined;
-export type Exact<T extends Record<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 Record<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 UndoRedoAction = RedoAction | 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;
-    scope: OperationScope;
-};
-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;
-    scope: OperationScope;
-};
-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;
-    scope: OperationScope;
-};
-export type Set_Name = "SET_NAME";
-export type SetNameAction = {
-    input: Scalars["String"]["input"];
-    type: Set_Name;
-    scope: "global";
-};
-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;
-    scope: OperationScope;
-};
-export type NOOP = "NOOP";
-export type NOOPAction = {
-    input: Scalars["Unknown"]["input"];
-    type: NOOP;
-    scope: OperationScope;
-};

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

@@ -1,116 +0,0 @@
-import { z } from 'zod';
-import { Action, DocumentFile, Load_State, LoadStateAction, LoadStateActionInput, LoadStateActionStateInput, Operation, Prune, PruneAction, PruneActionInput, Redo, RedoAction, Set_Name, SetNameAction, SetNameOperation, Undo, 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, definedNonNullAny, 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: OperationScope;
-}, {
-    input: LoadStateActionInput;
-    type: Load_State;
-    scope: OperationScope;
-}>, 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: OperationScope;
-}, {
-    input: PruneActionInput;
-    type: Prune;
-    scope: OperationScope;
-}>, 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: import('./types').Scalars["Int"]["input"];
-    type: Redo;
-    scope: OperationScope;
-}, {
-    input: import('./types').Scalars["Int"]["input"];
-    type: Redo;
-    scope: OperationScope;
-}>, 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: import('./types').Scalars["String"]["input"];
-    type: Set_Name;
-    scope: "global";
-}, {
-    input: import('./types').Scalars["String"]["input"];
-    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: import('./types').Scalars["Int"]["input"];
-    type: Undo;
-    scope: OperationScope;
-}, {
-    input: import('./types').Scalars["Int"]["input"];
-    type: Undo;
-    scope: OperationScope;
-}>]>;
-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;
-    message?: 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;
-    message?: 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;
-    message?: string | undefined;
-    description?: string | undefined;
-} & {
-    coerce?: boolean | undefined;
-}) | undefined) => z.ZodNumber;
-export declare function UndoActionSchema(): z.ZodObject<Properties<UndoAction>>;
-export {};

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

@@ -1,271 +0,0 @@
-import { Draft } from 'mutative';
-import { FC } from 'react';
-import { DocumentModelState } from '../document-model/';
-import { 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 { BaseAction } from './actions/types';
-export type { Immutable } from 'mutative';
-export type Signature = [string, string, string, string, string];
-export type ActionSigner = {
-    user: {
-        address: string;
-        networkId: string;
-        chainId: number;
-    };
-    app: {
-        name: string;
-        key: string;
-    };
-    signatures: Signature[];
-};
-export type ActionContext = {
-    signer?: ActionSigner;
-};
-/**
- * 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;
-    /** The context of the action. */
-    context?: ActionContext;
-};
-export type ActionWithAttachment<T extends string = string, I = unknown, S extends OperationScope = OperationScope> = Action<T, I, S> & {
-    attachments: AttachmentInput[];
-};
-export type ReducerOptions = {
-    /** The number of operations to skip before this new action is applied */
-    skip?: number;
-    /** When true the skip count is ignored and the action is applied regardless of the skip count */
-    ignoreSkipOperations?: boolean;
-    /** if true reuses the provided action hash  */
-    reuseHash?: boolean;
-    /** if true reuses the provided action resulting state instead of replaying it */
-    reuseOperationResultingState?: boolean;
-    /** Optional parser for the operation resulting state, uses JSON.parse by default */
-    operationResultingStateParser?: (state: unknown) => object;
-};
-/**
- * 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, options?: ReducerOptions) => Document<State, A, LocalState>;
-/**
- * A {@link Reducer} that prevents mutable code from changing the previous state.
- *
- * @remarks
- * This reducer is wrapped with {@link https://mutative.js.org/ | Mutative}.
- * 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;
-export type MutableStateReducer<S, A extends Action, L = unknown> = (state: State<S, L>, action: A, dispatch?: SignalDispatch) => State<S, L> | undefined;
-export type StateReducer<S, A extends Action, L = unknown> = ImmutableStateReducer<S, A, L> | MutableStateReducer<S, A, L>;
-/**
- * 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 number of operations skipped with this Operation */
-    skip: number;
-    /** Error message for a failed action */
-    error?: string;
-    /** The resulting state after the operation */
-    resultingState?: unknown;
-    /** Unique operation id */
-    id?: 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>[]>>;
-export type MappedOperation<A extends Action> = {
-    ignore: boolean;
-    operation: Operation<A | BaseAction>;
-};
-export type DocumentOperationsIgnoreMap<A extends Action> = Required<Record<OperationScope, MappedOperation<A>[]>>;
-export type OperationSignatureContext = {
-    documentId: string;
-    signer: Omit<ActionSigner, "signatures"> & {
-        signatures?: Signature[];
-    };
-    operation: Operation;
-    previousStateHash: string;
-};
-export type OperationSigningHandler = (message: Uint8Array) => Promise<Uint8Array>;
-export type OperationVerificationHandler = (publicKey: string, signature: Uint8Array, data: Uint8Array) => Promise<boolean>;
-/**
- * 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>;
-    /** A list of undone operations */
-    clipboard: Operation<BaseAction | A>[];
-};
-/**
- * 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 ENSInfo = {
-    name?: string;
-    avatarUrl?: string;
-};
-export type User = {
-    address: `0x${string}`;
-    networkId: string;
-    chainId: number;
-    ens?: ENSInfo;
-};
-export type EditorContext = {
-    theme: "light" | "dark";
-    debug?: boolean;
-    user?: User;
-};
-export type ActionErrorCallback = (error: unknown) => void;
-export type EditorProps<S, A extends Action, L> = {
-    document: Document<S, A, L>;
-    dispatch: (action: A | BaseAction, onErrorCallback?: ActionErrorCallback) => void;
-    context: EditorContext;
-    error?: unknown;
-};
-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[];
-};
-export type UndoRedoProcessResult<T, A extends Action, L> = {
-    document: Document<T, A, L>;
-    action: A | BaseAction;
-    skip: number;
-    reuseLastOperationIndex: boolean;
-};
-export type ValidationError = {
-    message: string;
-    details: object;
-};

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

@@ -1,87 +0,0 @@
-import { baseReducer, mutableBaseReducer } from '../reducer';
-import { Action, BaseAction, UndoRedoAction, Document, ExtendedState, ImmutableStateReducer, Reducer, OperationScope, State, CreateState, PartialState, DocumentOperations, DocumentHeader, DocumentOperationsIgnoreMap, Operation, MappedOperation, ReducerOptions, UndoAction } from '../types';
-import { SignalDispatch } from '../signal';
-export declare function isNoopOperation(op: Partial<Operation>): boolean;
-export declare function isUndoRedo(action: Action): action is UndoRedoAction;
-export declare function isUndo(action: Action): action is UndoAction;
-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.
- * @param attachments - The attachments included in the action.
- * @param validator - The validator to use for the input properties.
- * @param scope - The scope of the action, can either be 'global' or 'local'.
- * @param skip - The number of operations to skip before this new action is applied.
- *
- * @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 function createUnsafeReducer<S = unknown, A extends Action = Action, L = unknown>(reducer: ImmutableStateReducer<S, A, L>, documentReducer?: typeof mutableBaseReducer): Reducer<S, A, L>;
-export declare const createExtendedState: <S, L>(initialState?: Partial<ExtendedState<PartialState<S>, PartialState<L>>>, createState?: CreateState<S, L>) => 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>>>, createState?: (state?: Partial<State<PartialState<S>, PartialState<L>>>) => State<S, L>) => 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): Readonly<T>;
-/**
- * Maps skipped operations in an array of operations.
- * Skipped operations are operations that are ignored during processing.
- * @param operations - The array of operations to map.
- * @param skippedHeadOperations - The number of operations to skip at the head of the array of operations.
- * @returns An array of mapped operations with ignore flag indicating if the operation is skipped.
- * @throws Error if the operation index is invalid and there are missing operations.
- */
-export declare function mapSkippedOperations<A extends Action>(operations: Operation<BaseAction | A>[], skippedHeadOperations?: number): MappedOperation<A>[];
-export declare function sortOperations<A extends Action>(operations: DocumentOperations<A>): Operation<BaseAction | A>[];
-export declare function sortMappedOperations<A extends Action>(operations: DocumentOperationsIgnoreMap<A>): MappedOperation<A>[];
-export declare function replayOperations<T, A extends Action, L>(initialState: ExtendedState<T, L>, clearedOperations: DocumentOperations<A>, reducer: ImmutableStateReducer<T, A, L>, dispatch?: SignalDispatch, header?: DocumentHeader, documentReducer?: typeof baseReducer, skipHeaderOperations?: SkipHeaderOperations, options?: ReducerOptions): Document<T, A, L>;
-export type SkipHeaderOperations = Partial<Record<OperationScope, number>>;
-export type ReplayDocumentOptions = {
-    checkHashes?: boolean;
-    reuseOperationResultingState?: boolean;
-    operationResultingStateParser?: (state: unknown) => object;
-};
-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, skipHeaderOperations?: SkipHeaderOperations, options?: ReplayDocumentOptions): Document<T, A, L>;
-export declare function isSameDocument(documentA: Document, documentB: Document): boolean;
-export declare function parseResultingState(state: unknown): object;

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

@@ -1,9 +0,0 @@
-import { Action, ActionSigner, BaseAction, Document, Operation, OperationSignatureContext, OperationSigningHandler, OperationVerificationHandler, Reducer, Signature } from '../types';
-export declare function getUnixTimestamp(date: Date | string): string;
-export declare function buildOperationSignatureParams({ documentId, signer, operation, previousStateHash, }: OperationSignatureContext): [string, string, string, string];
-export declare function buildOperationSignatureMessage(params: [string, string, string, string]): Uint8Array;
-export declare function ab2hex(ab: ArrayBuffer): string;
-export declare function hex2ab(hex: string): Uint8Array;
-export declare function buildOperationSignature(context: OperationSignatureContext, signMethod: OperationSigningHandler): Promise<Signature>;
-export declare function buildSignedOperation<T, A extends Action, L>(action: A | Operation<A>, reducer: Reducer<T, A, L>, document: Document<T, A, L>, context: Omit<OperationSignatureContext, "operation" | "previousStateHash">, signHandler: OperationSigningHandler): Promise<Operation<A | BaseAction>>;
-export declare function verifyOperationSignature<T, A extends Action, L>(signature: Signature, signer: Omit<ActionSigner, "signatures">, verifyHandler: OperationVerificationHandler): Promise<boolean>;