document-model 4.1.0-dev.9 → 4.1.0-dev.91

package/dist/src/{document/schema/zod.js → core/schemas.js}

@@ -8,12 +8,6 @@ export const PruneSchema = z.enum(["PRUNE"]);
 export const RedoSchema = z.enum(["REDO"]);
 export const Set_NameSchema = z.enum(["SET_NAME"]);
 export const UndoSchema = z.enum(["UNDO"]);
-export function ActionSchema() {
-    return z.object({
-        __typename: z.literal("Action").optional(),
-        type: z.string(),
-    });
-}
 export function OperationScopeSchema() {
     return z.string();
 }
@@ -37,6 +31,8 @@ export function DocumentFileSchema() {
 }
 export function LoadStateActionSchema() {
     return z.object({
+        id: z.string(),
+        timestampUtcMs: z.string(),
         input: z.lazy(() => LoadStateActionInputSchema()),
         type: Load_StateSchema,
         scope: OperationScopeSchema(),
@@ -54,17 +50,10 @@ export function LoadStateActionStateInputSchema() {
         name: z.string(),
     });
 }
-export function OperationSchema() {
-    return z.object({
-        __typename: z.literal("Operation").optional(),
-        hash: z.string(),
-        index: z.number(),
-        timestamp: z.string().datetime(),
-        type: z.string(),
-    });
-}
 export function PruneActionSchema() {
     return z.object({
+        id: z.string(),
+        timestampUtcMs: z.string(),
         input: z.lazy(() => PruneActionInputSchema()),
         type: PruneSchema,
         scope: OperationScopeSchema(),
@@ -79,6 +68,8 @@ export function PruneActionInputSchema() {
 export const RedoActionInputSchema = z.number;
 export function RedoActionSchema() {
     return z.object({
+        id: z.string(),
+        timestampUtcMs: z.string().datetime(),
         input: RedoActionInputSchema(),
         type: RedoSchema,
         scope: OperationScopeSchema(),
@@ -87,27 +78,33 @@ export function RedoActionSchema() {
 export const SetNameActionInputSchema = z.string;
 export function SetNameActionSchema() {
     return z.object({
+        id: z.string(),
+        timestampUtcMs: z.string().datetime(),
         input: SetNameActionInputSchema(),
         type: Set_NameSchema,
         scope: z.literal("global"),
     });
 }
-export function SetNameOperationSchema() {
-    return z.object({
-        __typename: z.literal("SetNameOperation").optional(),
-        hash: z.string(),
-        index: z.number(),
-        input: z.string(),
-        timestamp: z.string().datetime(),
-        type: z.string(),
-    });
-}
+// export function SetNameOperationSchema(): z.ZodObject<
+//   Properties<SetNameOperation>
+// > {
+//   return z.object({
+//     __typename: z.literal("SetNameOperation").optional(),
+//     hash: z.string(),
+//     index: z.number(),
+//     input: z.string(),
+//     timestampUtcMs: z.string().datetime(),
+//     type: z.string(),
+//   });
+// }
 export const UndoActionInputSchema = z.number;
 export function UndoActionSchema() {
     return z.object({
+        id: z.string(),
+        timestampUtcMs: z.string().datetime(),
         input: UndoActionInputSchema(),
         type: UndoSchema,
         scope: OperationScopeSchema(),
     });
 }
-//# sourceMappingURL=zod.js.map
+//# sourceMappingURL=schemas.js.map

package/dist/src/core/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../../src/core/schemas.ts"],"names":[],"mappings":"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"}

package/dist/src/core/state.d.ts

@@ -0,0 +1,26 @@
+import type { PHAuthState, PHBaseState, PHDocumentState } from "./ph-types.js";
+/**
+ * Creates a default PHAuthState
+ */
+export declare function defaultAuthState(): PHAuthState;
+/**
+ * Creates a default PHDocumentState
+ */
+export declare function defaultDocumentState(): PHDocumentState;
+/**
+ * Creates a default PHBaseState with auth and document properties
+ */
+export declare function defaultBaseState(): PHBaseState;
+/**
+ * Creates a PHAuthState with the given properties
+ */
+export declare function createAuthState(auth?: Partial<PHAuthState>): PHAuthState;
+/**
+ * Creates a PHDocumentState with the given properties
+ */
+export declare function createDocumentState(document?: Partial<PHDocumentState>): PHDocumentState;
+/**
+ * Creates a PHBaseState with the given auth and document properties
+ */
+export declare function createBaseState(auth?: Partial<PHAuthState>, document?: Partial<PHDocumentState>): PHBaseState;
+//# sourceMappingURL=state.d.ts.map

package/dist/src/core/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/core/state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAG/E;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,WAAW,CAE9C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,eAAe,CAQtD;AACD;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,WAAW,CAK9C;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAKxE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAClC,eAAe,CAKjB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,IAAI,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,EAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAClC,WAAW,CAKb"}

package/dist/src/core/state.js

@@ -0,0 +1,56 @@
+import { HASH_ALGORITHM_SHA1, HASH_ENCODING_BASE64 } from "./ph-types.js";
+/**
+ * Creates a default PHAuthState
+ */
+export function defaultAuthState() {
+    return {};
+}
+/**
+ * Creates a default PHDocumentState
+ */
+export function defaultDocumentState() {
+    return {
+        version: "1.0.0",
+        hash: {
+            algorithm: HASH_ALGORITHM_SHA1,
+            encoding: HASH_ENCODING_BASE64,
+        },
+    };
+}
+/**
+ * Creates a default PHBaseState with auth and document properties
+ */
+export function defaultBaseState() {
+    return {
+        auth: defaultAuthState(),
+        document: defaultDocumentState(),
+    };
+}
+/**
+ * Creates a PHAuthState with the given properties
+ */
+export function createAuthState(auth) {
+    return {
+        ...defaultAuthState(),
+        ...auth,
+    };
+}
+/**
+ * Creates a PHDocumentState with the given properties
+ */
+export function createDocumentState(document) {
+    return {
+        ...defaultDocumentState(),
+        ...document,
+    };
+}
+/**
+ * Creates a PHBaseState with the given auth and document properties
+ */
+export function createBaseState(auth, document) {
+    return {
+        auth: createAuthState(auth),
+        document: createDocumentState(document),
+    };
+}
+//# sourceMappingURL=state.js.map

package/dist/src/core/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","sourceRoot":"","sources":["../../../src/core/state.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1E;;GAEG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO,EAAE,CAAC;AACZ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO;QACL,OAAO,EAAE,OAAO;QAChB,IAAI,EAAE;YACJ,SAAS,EAAE,mBAAmB;YAC9B,QAAQ,EAAE,oBAAoB;SAC/B;KACF,CAAC;AACJ,CAAC;AACD;;GAEG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO;QACL,IAAI,EAAE,gBAAgB,EAAE;QACxB,QAAQ,EAAE,oBAAoB,EAAE;KACjC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,IAA2B;IACzD,OAAO;QACL,GAAG,gBAAgB,EAAE;QACrB,GAAG,IAAI;KACR,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,mBAAmB,CACjC,QAAmC;IAEnC,OAAO;QACL,GAAG,oBAAoB,EAAE;QACzB,GAAG,QAAQ;KACZ,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAC7B,IAA2B,EAC3B,QAAmC;IAEnC,OAAO;QACL,IAAI,EAAE,eAAe,CAAC,IAAI,CAAC;QAC3B,QAAQ,EAAE,mBAAmB,CAAC,QAAQ,CAAC;KACxC,CAAC;AACJ,CAAC"}

package/dist/src/core/types.d.ts

@@ -0,0 +1,481 @@
+import type { Draft } from "mutative";
+import type { FC, ReactNode } from "react";
+import type { Action, ActionSigner, AttachmentRef, Operation, PHBaseState, PHDocument } from "./ph-types.js";
+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 OperationsByScope = Partial<Record<string, Operation[]>>;
+export type SkipHeaderOperationIndex = Partial<Pick<OperationIndex, "index">> & Pick<OperationIndex, "skip">;
+export type UndoRedoAction = SchemaRedoAction | SchemaUndoAction;
+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"];
+    timestampUtcMs: Scalars["DateTime"]["output"];
+    type: Scalars["String"]["output"];
+};
+export type Load_State = "LOAD_STATE";
+export type SchemaLoadStateAction = {
+    id: Scalars["String"]["output"];
+    timestampUtcMs: Scalars["DateTime"]["output"];
+    input: LoadStateActionInput;
+    type: Load_State;
+    scope: string;
+};
+export type LoadStateActionInput = {
+    operations: Scalars["Int"]["input"];
+    state: LoadStateActionStateInput;
+};
+export type LoadStateActionStateInput = {
+    data?: InputMaybe<Scalars["Unknown"]["input"]>;
+    name: Scalars["String"]["input"];
+};
+export type MutationLoadStateArgs = {
+    input: SchemaLoadStateAction;
+};
+export type MutationPruneArgs = {
+    input: SchemaPruneAction;
+};
+export type MutationRedoArgs = {
+    input: SchemaRedoAction;
+};
+export type MutationSetNameArgs = {
+    input: SchemaSetNameAction;
+};
+export type MutationUndoArgs = {
+    input: SchemaUndoAction;
+};
+export type Prune = "PRUNE";
+export type SchemaPruneAction = {
+    id: Scalars["String"]["output"];
+    timestampUtcMs: Scalars["DateTime"]["output"];
+    input: PruneActionInput;
+    type: Prune;
+    scope: string;
+};
+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 SchemaRedoAction = {
+    id: Scalars["String"]["output"];
+    timestampUtcMs: Scalars["DateTime"]["output"];
+    input: Scalars["Int"]["input"];
+    type: Redo;
+    scope: string;
+};
+export type Set_Name = "SET_NAME";
+export type SchemaSetNameAction = {
+    id: Scalars["String"]["output"];
+    timestampUtcMs: Scalars["DateTime"]["output"];
+    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 SchemaUndoAction = {
+    id: Scalars["String"]["output"];
+    timestampUtcMs: Scalars["DateTime"]["output"];
+    input: Scalars["Int"]["input"];
+    type: Undo;
+    scope: string;
+};
+export type SchemaNOOPAction = {
+    id: Scalars["String"]["output"];
+    input: Scalars["Unknown"]["input"];
+    scope: string;
+    timestampUtcMs: Scalars["DateTime"]["output"];
+    type: "NOOP";
+};
+export type LoadStateAction = Action & {
+    type: "LOAD_STATE";
+    input: LoadStateActionInput;
+};
+export type PruneAction = Action & {
+    type: "PRUNE";
+    input: PruneActionInput;
+};
+export type RedoAction = Action & {
+    type: "REDO";
+    input: SchemaRedoAction["input"];
+};
+export type SetNameAction = Action & {
+    type: "SET_NAME";
+    input: SchemaSetNameAction["input"];
+};
+export type UndoAction = Action & {
+    type: "UNDO";
+    input: SchemaUndoAction["input"];
+};
+export type NOOPAction = Action & {
+    type: "NOOP";
+    input: SchemaNOOPAction["input"];
+};
+export type CreateDocumentActionInput = {
+    model: string;
+    version: "0.0.0";
+    documentId: string;
+    signing?: {
+        signature: string;
+        publicKey: JsonWebKey;
+        nonce: string;
+        createdAtUtcIso: string;
+        documentType: string;
+    };
+    slug?: string;
+    name?: string;
+    branch?: string;
+    meta?: Record<string, unknown>;
+};
+export type UpgradeDocumentActionInput = {
+    model: string;
+    fromVersion: string;
+    toVersion: string;
+    documentId: string;
+    initialState?: object;
+};
+export type DeleteDocumentActionInput = {
+    documentId: string;
+    propagate?: "none" | "cascade";
+};
+export type CreateDocumentAction = Action & {
+    type: "CREATE_DOCUMENT";
+    input: CreateDocumentActionInput;
+};
+export type UpgradeDocumentAction = Action & {
+    type: "UPGRADE_DOCUMENT";
+    input: UpgradeDocumentActionInput;
+};
+export type DeleteDocumentAction = Action & {
+    type: "DELETE_DOCUMENT";
+    input: DeleteDocumentActionInput;
+};
+export type DocumentAction = LoadStateAction | PruneAction | RedoAction | SetNameAction | UndoAction | NOOPAction;
+export interface ISignal<TType extends string, TInput> {
+    type: TType;
+    input: TInput;
+}
+export type ISignalResult<TTYpe, TInput, TResult> = {
+    signal: {
+        type: TTYpe;
+        input: TInput;
+    };
+    result: TResult;
+};
+export type CreateChildDocumentInput = {
+    id: string;
+    documentType: string;
+};
+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 | CopyChildDocumentSignal | DeleteChildDocumentSignal;
+export type SignalDispatch = (signal: Signal) => void;
+export type SignalResult = ISignalResult<CreateChildDocumentSignal["type"], CreateChildDocumentSignal["input"], PHDocument> | ISignalResult<CopyChildDocumentSignal["type"], CopyChildDocumentSignal["input"], boolean> | ISignalResult<DeleteChildDocumentSignal["type"], DeleteChildDocumentSignal["input"], PHDocument>;
+export type SignalResults = {
+    CREATE_CHILD_DOCUMENT: PHDocument;
+    COPY_CHILD_DOCUMENT: PHDocument;
+    DELETE_CHILD_DOCUMENT: boolean;
+};
+export type SignalType<T extends Signal> = T["type"];
+export type FileInput = string | number[] | Uint8Array | ArrayBuffer | Blob;
+export type ActionWithAttachment = Action & {
+    attachments: AttachmentInput[];
+};
+export type ReducerOptions = {
+    /** The number of operations to skip before this new action is applied. This overrides the skip count in the operation. */
+    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 resulting state instead of replaying it */
+    reuseOperationResultingState?: boolean;
+    /** if true checks the hashes of the operations */
+    checkHashes?: boolean;
+    /** Options for performing a replay. */
+    replayOptions?: {
+        /** The previously created operation to verify against. */
+        operation: Operation;
+    };
+    /** Optional parser for the operation resulting state, uses JSON.parse by default */
+    operationResultingStateParser?: <TState>(state: string | null | undefined) => TState;
+    /**
+     * When true (default), the reducer will prune operations (garbage collect) when processing a skip.
+     * When false, it will recompute state for the skip but preserve the existing operations history.
+     */
+    pruneOnSkip?: boolean;
+};
+/**
+ * A pure function that takes an action and the previous state
+ * of the document and returns the new state.
+ */
+export type Reducer<TState extends PHBaseState = PHBaseState> = (document: PHDocument<TState>, action: Action, dispatch?: SignalDispatch, options?: ReducerOptions) => PHDocument<TState>;
+export type StateReducer<TState extends PHBaseState = PHBaseState> = (state: Draft<TState>, action: Action, dispatch?: SignalDispatch) => TState | undefined;
+export type PHStateReducer<TState extends PHBaseState = PHBaseState> = StateReducer<TState>;
+export type Meta = {
+    preferredEditor?: 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 PartialState<TState> = TState | Partial<TState>;
+export type CreateState<TState extends PHBaseState = PHBaseState> = (state?: PartialState<TState>) => TState;
+export type SaveToFileHandle = (document: PHDocument, input: FileSystemFileHandle) => void | Promise<void>;
+export type SaveToFile = (document: PHDocument, path: string, name?: string) => string | Promise<string>;
+export type LoadFromInput<TState extends PHBaseState = PHBaseState> = (input: FileInput) => PHDocument<TState> | Promise<PHDocument<TState>>;
+export type LoadFromFile<TState extends PHBaseState = PHBaseState> = (path: string) => PHDocument<TState> | Promise<PHDocument<TState>>;
+export type CreateDocument<TState extends PHBaseState = PHBaseState> = (initialState?: Partial<TState>, createState?: CreateState<TState>) => PHDocument<TState>;
+export type MappedOperation = {
+    ignore: boolean;
+    operation: Operation;
+};
+export type DocumentOperationsIgnoreMap = Record<string, MappedOperation[]>;
+export type ActionSignatureContext = {
+    documentId: string;
+    signer: ActionSigner;
+    action: Action;
+    previousStateHash: string;
+};
+export type ActionSigningHandler = (message: Uint8Array) => Promise<Uint8Array>;
+export type ActionVerificationHandler = (publicKey: string, signature: Uint8Array, data: Uint8Array) => Promise<boolean>;
+export type ENSInfo = {
+    name?: string;
+    avatarUrl?: string;
+};
+export type User = {
+    address: `0x${string}`;
+    networkId: string;
+    chainId: number;
+    ens?: ENSInfo;
+};
+export type PartialRecord<K extends keyof any, T> = {
+    [P in K]?: T;
+};
+export type RevisionsFilter = PartialRecord<string, number>;
+export type GetDocumentOptions = ReducerOptions & {
+    revisions?: RevisionsFilter;
+    checkHashes?: boolean;
+};
+export type ActionErrorCallback = (error: unknown) => void;
+export type EditorDispatch = (action: Action, onErrorCallback?: ActionErrorCallback) => void;
+export type EditorProps = {
+    children?: ReactNode;
+    className?: string;
+    document?: PHDocument;
+};
+export type SubgraphModule = {
+    id: string;
+    name: string;
+    gql: string;
+    endpoint: string;
+};
+export type ImportScriptModule = {
+    id: string;
+    name: string;
+    gql: string;
+    endpoint: string;
+};
+export type EditorModule<TProps = any> = {
+    Component: FC<EditorProps & TProps>;
+    documentTypes: string[];
+    config: {
+        id: string;
+        name: string;
+    };
+};
+export type App = {
+    id: string;
+    name: string;
+    driveEditor?: string;
+};
+export type Manifest = {
+    name: string;
+    description: string;
+    category: string;
+    publisher: {
+        name: string;
+        url: string;
+    };
+    documentModels?: {
+        id: string;
+        name: string;
+    }[];
+    editors?: {
+        id: string;
+        name: string;
+        documentTypes: string[];
+    }[];
+    processors?: {
+        id: string;
+        name: string;
+    }[];
+    subgraphs?: {
+        id: string;
+        name: string;
+    }[];
+    importScripts?: {
+        id: string;
+        name: string;
+        documentTypes: string[];
+    }[];
+    apps?: App[];
+};
+export type ValidationError = {
+    message: string;
+    details: object;
+};
+export type SkipHeaderOperations = Partial<Record<string, number>>;
+export type ReplayDocumentOptions = {
+    checkHashes?: boolean;
+    reuseOperationResultingState?: boolean;
+    operationResultingStateParser?: <TState>(state: string) => TState;
+};
+export type OperationIndex = {
+    index: number;
+    skip: number;
+    id?: string;
+    timestampUtcMs?: string;
+};
+/**
+ * Parameters used in a document signature.
+ */
+export type SigningParameters = {
+    documentType: string;
+    createdAtUtcIso: string;
+    /**
+     * The nonce can act as both a salt and a typical nonce.
+     */
+    nonce: string;
+};
+/**
+ * Describes a signer. This may only have a public key for verification.
+ */
+export interface ISigner {
+    /** The corresponding public key */
+    publicKey(): Promise<JsonWebKey>;
+    /**
+     * Signs data.
+     *
+     * @param data - The data to sign.
+     *
+     * @returns The signature of the data.
+     */
+    sign: (data: Uint8Array) => Promise<Uint8Array>;
+    /**
+     * Verifies a signature.
+     *
+     * @param data - The data to verify.
+     * @param signature - The signature to verify.
+     */
+    verify: (data: Uint8Array, signature: Uint8Array) => Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map