@roc-db/test-utils 0.2.0-pre.4 → 0.2.0-pre.40

package/dist/types/inMemoryAdapter.d.ts

@@ -0,0 +1 @@
+export declare const inMemoryAdapter: any;

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./schemas";
+export { operations } from "./operations";
+export { testAdapterImplementation } from "./testAdapterImplementation";
+export { inMemoryAdapter } from "./inMemoryAdapter";

package/dist/types/operations/applyDraft.d.ts

@@ -0,0 +1,5 @@
+export declare const applyDraft: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, any>;

package/dist/types/operations/createBlockImage.d.ts

@@ -0,0 +1,7 @@
+export declare const createBlockImage: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>;

package/dist/types/operations/createBlockParagraph.d.ts

@@ -0,0 +1,7 @@
+export declare const createBlockParagrah: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>;

package/dist/types/operations/createBlockRow.d.ts

@@ -0,0 +1,7 @@
+export declare const createBlockRow: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>;

package/dist/types/operations/createBlockTitle.d.ts

@@ -0,0 +1,7 @@
+export declare const createBlockTitle: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>;

package/dist/types/operations/createDraft.d.ts

@@ -0,0 +1,7 @@
+export declare const createDraft: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>;

package/dist/types/operations/createPost.d.ts

@@ -0,0 +1,7 @@
+export declare const createPost: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>;

package/dist/types/operations/deleteBlocks.d.ts

@@ -0,0 +1,7 @@
+export declare const deleteBlocks: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>;

package/dist/types/operations/deletePost.d.ts

@@ -0,0 +1,5 @@
+export declare const deletePost: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, any>;

package/dist/types/operations/index.d.ts

@@ -0,0 +1,83 @@
+export declare const operations: readonly [import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, any>, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, any>, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, any>, any, any, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, `BlockParagraph/${string}`>, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>];

package/dist/types/operations/moveBlocks.d.ts

@@ -0,0 +1,5 @@
+export declare const moveBlocks: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, any>;

package/dist/types/operations/readEntity.d.ts

@@ -0,0 +1 @@
+export declare const readEntity: any;

package/dist/types/operations/readPost.d.ts

@@ -0,0 +1 @@
+export declare const readPost: any;

package/dist/types/operations/testTransactionalEdits.d.ts

@@ -0,0 +1,7 @@
+export declare const testTransactionalEdits: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>;

package/dist/types/operations/updateBlockParagraph.d.ts

@@ -0,0 +1,5 @@
+export declare const updateBlockParagraph: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, `BlockParagraph/${string}`>;

package/dist/types/operations/updatePost.d.ts

@@ -0,0 +1,7 @@
+export declare const updatePost: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>;

package/dist/types/operations/updatePostDescription.d.ts

@@ -0,0 +1,7 @@
+export declare const updatePostDescription: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>;

package/dist/types/operations/updatePostTitle.d.ts

@@ -0,0 +1,7 @@
+export declare const updatePostTitle: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, {
+    [x: string]: any;
+}>;

package/dist/types/schemas/ApplyDraftMutationSchema.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+export declare const ApplyDraftMutationSchema: z.ZodObject<z.objectUtil.extendShape<{
+    ref: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+    timestamp: z.ZodString;
+    changeSetRef: z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
+    payload: z.ZodAny;
+    log: z.ZodArray<z.ZodAny, "many">;
+    debounceCount: z.ZodNumber;
+    identityRef: z.ZodString;
+    sessionRef: z.ZodOptional<z.ZodString>;
+}, {
+    operation: z.ZodObject<{
+        name: z.ZodLiteral<"applyDraft">;
+        version: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: "applyDraft";
+        version: number;
+    }, {
+        name: "applyDraft";
+        version?: number | undefined;
+    }>;
+    changeSetRef: z.ZodType<never, z.ZodTypeDef, never> | z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
+    payload: z.ZodObject<{
+        ref: z.ZodType<`Draft/${string}`, z.ZodTypeDef, `Draft/${string}`>;
+    }, "strict", z.ZodTypeAny, {
+        ref: `Draft/${string}`;
+    }, {
+        ref: `Draft/${string}`;
+    }>;
+    log: z.ZodType<any[], z.ZodTypeDef, any[]>;
+}>, "strict", z.ZodTypeAny, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Draft/${string}`;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "applyDraft";
+        version: number;
+    };
+    sessionRef?: string | undefined;
+}, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Draft/${string}`;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "applyDraft";
+        version?: number | undefined;
+    };
+    sessionRef?: string | undefined;
+}>;

package/dist/types/schemas/BlockImageRefSchema.d.ts

@@ -0,0 +1 @@
+export declare const BlockImageRefSchema: import("zod").ZodType<`BlockImage/${string}`, import("zod").ZodTypeDef, `BlockImage/${string}`>;

package/dist/types/schemas/BlockImageSchema.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const BlockImageSchema: z.ZodObject<z.objectUtil.extendShape<{
+    ref: z.ZodType<never, z.ZodTypeDef, never>;
+    entity: z.ZodString;
+    created: z.ZodObject<{
+        mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }>;
+    updated: z.ZodObject<{
+        mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }>;
+    data: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    parents: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    ancestors: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, z.ZodRawShape>, "strict", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>;

package/dist/types/schemas/BlockParagraphRefSchema.d.ts

@@ -0,0 +1 @@
+export declare const BlockParagraphRefSchema: import("zod").ZodType<`BlockParagraph/${string}`, import("zod").ZodTypeDef, `BlockParagraph/${string}`>;

package/dist/types/schemas/BlockParagraphSchema.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export declare const BlockParagraphSchema: z.ZodObject<z.objectUtil.extendShape<{
+    ref: z.ZodType<never, z.ZodTypeDef, never>;
+    entity: z.ZodString;
+    created: z.ZodObject<{
+        mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }>;
+    updated: z.ZodObject<{
+        mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }>;
+    data: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    parents: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    ancestors: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, z.ZodRawShape>, "strict", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>;
+export type BlockParagraph = z.infer<typeof BlockParagraphSchema>;

package/dist/types/schemas/BlockRefSchema.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare const BlockRefSchema: z.ZodUnion<[z.ZodType<`BlockParagraph/${string}`, z.ZodTypeDef, `BlockParagraph/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>;

package/dist/types/schemas/BlockRowRefSchema.d.ts

@@ -0,0 +1 @@
+export declare const BlockRowRefSchema: import("zod").ZodType<`BlockRow/${string}`, import("zod").ZodTypeDef, `BlockRow/${string}`>;

package/dist/types/schemas/BlockRowSchema.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export declare const BlockRowSchema: z.ZodObject<z.objectUtil.extendShape<{
+    ref: z.ZodType<never, z.ZodTypeDef, never>;
+    entity: z.ZodString;
+    created: z.ZodObject<{
+        mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }>;
+    updated: z.ZodObject<{
+        mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }>;
+    data: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    parents: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    ancestors: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, z.ZodRawShape>, "strict", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>;
+export type BlockRow = z.infer<typeof BlockRowSchema>;

package/dist/types/schemas/BlockTitleRefSchema.d.ts

@@ -0,0 +1 @@
+export declare const BlockTitleRefSchema: import("zod").ZodType<`BlockTitle/${string}`, import("zod").ZodTypeDef, `BlockTitle/${string}`>;

package/dist/types/schemas/BlockTitleSchema.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const BlockTitleSchema: z.ZodObject<z.objectUtil.extendShape<{
+    ref: z.ZodType<never, z.ZodTypeDef, never>;
+    entity: z.ZodString;
+    created: z.ZodObject<{
+        mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }>;
+    updated: z.ZodObject<{
+        mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }>;
+    data: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    parents: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    ancestors: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, z.ZodRawShape>, "strict", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>;

package/dist/types/schemas/CreateBlockImageMutationSchema.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+export declare const CreateBlockImageMutationSchema: z.ZodObject<z.objectUtil.extendShape<{
+    ref: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+    timestamp: z.ZodString;
+    changeSetRef: z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
+    payload: z.ZodAny;
+    log: z.ZodArray<z.ZodAny, "many">;
+    debounceCount: z.ZodNumber;
+    identityRef: z.ZodString;
+    sessionRef: z.ZodOptional<z.ZodString>;
+}, {
+    operation: z.ZodObject<{
+        name: z.ZodLiteral<"createBlockImage">;
+        version: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: "createBlockImage";
+        version: number;
+    }, {
+        name: "createBlockImage";
+        version?: number | undefined;
+    }>;
+    changeSetRef: z.ZodType<never, z.ZodTypeDef, never> | z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
+    payload: z.ZodObject<{
+        postRef: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+    }, "strict", z.ZodTypeAny, {
+        postRef: `Post/${string}`;
+    }, {
+        postRef: `Post/${string}`;
+    }>;
+    log: z.ZodType<any[], z.ZodTypeDef, any[]>;
+}>, "strict", z.ZodTypeAny, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        postRef: `Post/${string}`;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "createBlockImage";
+        version: number;
+    };
+    sessionRef?: string | undefined;
+}, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        postRef: `Post/${string}`;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "createBlockImage";
+        version?: number | undefined;
+    };
+    sessionRef?: string | undefined;
+}>;

package/dist/types/schemas/CreateBlockParagraphMutationSchema.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+export declare const CreateBlockParagraphMutationSchema: z.ZodObject<z.objectUtil.extendShape<{
+    ref: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+    timestamp: z.ZodString;
+    changeSetRef: z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
+    payload: z.ZodAny;
+    log: z.ZodArray<z.ZodAny, "many">;
+    debounceCount: z.ZodNumber;
+    identityRef: z.ZodString;
+    sessionRef: z.ZodOptional<z.ZodString>;
+}, {
+    operation: z.ZodObject<{
+        name: z.ZodLiteral<"createBlockParagraph">;
+        version: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: "createBlockParagraph";
+        version: number;
+    }, {
+        name: "createBlockParagraph";
+        version?: number | undefined;
+    }>;
+    changeSetRef: z.ZodType<never, z.ZodTypeDef, never> | z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
+    payload: z.ZodObject<{
+        parentRef: z.ZodUnion<[z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>;
+    }, "strict", z.ZodTypeAny, {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    }, {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    }>;
+    log: z.ZodType<any[], z.ZodTypeDef, any[]>;
+}>, "strict", z.ZodTypeAny, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "createBlockParagraph";
+        version: number;
+    };
+    sessionRef?: string | undefined;
+}, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "createBlockParagraph";
+        version?: number | undefined;
+    };
+    sessionRef?: string | undefined;
+}>;

package/dist/types/schemas/CreateBlockRowMutationSchema.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+export declare const CreateBlockRowMutationSchema: z.ZodObject<z.objectUtil.extendShape<{
+    ref: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+    timestamp: z.ZodString;
+    changeSetRef: z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
+    payload: z.ZodAny;
+    log: z.ZodArray<z.ZodAny, "many">;
+    debounceCount: z.ZodNumber;
+    identityRef: z.ZodString;
+    sessionRef: z.ZodOptional<z.ZodString>;
+}, {
+    operation: z.ZodObject<{
+        name: z.ZodLiteral<"createBlockRow">;
+        version: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: "createBlockRow";
+        version: number;
+    }, {
+        name: "createBlockRow";
+        version?: number | undefined;
+    }>;
+    changeSetRef: z.ZodType<never, z.ZodTypeDef, never> | z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
+    payload: z.ZodObject<{
+        parentRef: z.ZodUnion<[z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>;
+    }, "strict", z.ZodTypeAny, {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    }, {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    }>;
+    log: z.ZodType<any[], z.ZodTypeDef, any[]>;
+}>, "strict", z.ZodTypeAny, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "createBlockRow";
+        version: number;
+    };
+    sessionRef?: string | undefined;
+}, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "createBlockRow";
+        version?: number | undefined;
+    };
+    sessionRef?: string | undefined;
+}>;