@roc-db/test-utils 0.2.0-pre.1 → 0.2.0-pre.11

package/dist/index.js

@@ -179,7 +179,6 @@ var createBlockRow = writeOperation3(CreateBlockRowMutationSchema, BlockParagrap
   const ref = txn.createRef("BlockRow");
   const { parentRef } = txn.payload;
   return QueryChain2(Query3(() => txn.readEntity(parentRef)), Query3((parent) => {
-    console.log("asdfasfd", parent);
     return txn.patchEntity(parentRef, {
       children: { blocks: [...parent.children.blocks, ref] }
     });
@@ -344,7 +343,7 @@ var operations = [
 ];
 // src/testAdapterImplementation.ts
 import { beforeAll, describe, expect, test } from "bun:test";
-import { NotFoundError as NotFoundError2 } from "roc-db";
+import { BadRequestError, NotFoundError as NotFoundError2 } from "roc-db";
 var prepareChangeSetTest = async (adapter) => {
   const [post] = await adapter.createPost({
     title: "Title 1",
@@ -378,54 +377,123 @@ var testAdapterImplementation = (adapterConstructor, engineArgsAdapter1 = {}, en
   return async () => {
     const adapter1 = adapterConstructor({ operations, entities, ...engineArgsAdapter1 });
     const adapter2 = adapterConstructor({ operations, entities, ...engineArgsAdapter2 });
+    describe("Post CRUD", async () => {
+      let postRef;
+      let post;
+      let createPostMutation;
+      beforeAll(async () => {
+        const createPostRes = await adapter1.createPost({
+          title: "Title 1",
+          slug: "title-1",
+          tags: ["Foo", "Bar"]
+        });
+        post = createPostRes[0];
+        postRef = createPostRes[0].ref;
+        createPostMutation = createPostRes[1];
+      });
+      test("create (createEntity function)", async () => {
+        expect(post).toMatchZodSchema(PostSchema);
+        expect(post.data.title).toBe("Title 1");
+        expect(post.data.tags).toStrictEqual(["Foo", "Bar"]);
+      });
+      test("read (readEntity function)", async () => {
+        const readPostRes = await adapter1.readPost(postRef);
+        expect(readPostRes.data.title).toStrictEqual("Title 1");
+        expect(readPostRes.data.tags).toStrictEqual(["Foo", "Bar"]);
+        expect(readPostRes).toMatchZodSchema(PostSchema);
+      });
+      test("update (updateEntity function)", async () => {
+        const [post2] = await adapter1.updatePost({
+          ref: postRef,
+          title: "Title 2",
+          tags: ["Foo"]
+        });
+        expect(post2.data.tags).toStrictEqual(["Foo"]);
+        expect(post2.data.title).toBe("Title 2");
+        expect(post2).toMatchZodSchema(PostSchema);
+      });
+      test("updateTitle (patchEntity function + debounce)", async () => {
+        const updatePostTitleRes1 = await adapter1.updatePostTitle({
+          ref: postRef,
+          title: "Title 3"
+        });
+        expect(updatePostTitleRes1[0]).toMatchZodSchema(PostSchema);
+        const updatePostTitleRes2 = await adapter1.updatePostTitle({
+          ref: postRef,
+          title: "Title 4"
+        });
+        expect(updatePostTitleRes2[0]).toMatchZodSchema(PostSchema);
+        expect(updatePostTitleRes2[1].ref).toBe(updatePostTitleRes1[1].ref);
+        expect(updatePostTitleRes2[1].timestamp >= updatePostTitleRes1[1].timestamp).toBeTrue();
+      });
+      test("delete (deleteEntity function)", async () => {
+        const [count, mutation] = await adapter1.deletePost(postRef);
+        expect(count).toBe(1);
+        expect(mutation.log).toStrictEqual([[postRef, "delete", null]]);
+      });
+      test("sync mutation", async () => {
+        const res = await adapter2.syncOptimisticMutation(createPostMutation);
+        expect(res[0]).toStrictEqual(post);
+        expect(res[1]).toStrictEqual(createPostMutation);
+        expect(() => adapter2.syncOptimisticMutation(createPostMutation)).toThrowError(BadRequestError);
+      });
+    });
     describe("changeSet", async () => {
-      let postRef, draftRef, changeSetAdapter, block, post, blockRow, blockParagraph2;
+      let postRef, draftRef, changeSetAdapter, blockParagraph1, post, blockRow, blockParagraph2;
       beforeAll(async () => {
-        const res = await prepareChangeSetTest(adapter1);
-        postRef = res.postRef;
-        draftRef = res.draftRef;
-        changeSetAdapter = res.changeSetAdapter;
-        block = res.blockParagraph1;
-        blockRow = res.blockRow;
-        blockParagraph2 = res.blockParagraph2;
-        post = res.post;
+        ({
+          postRef,
+          draftRef,
+          changeSetAdapter,
+          blockParagraph1,
+          post,
+          blockRow,
+          blockParagraph2
+        } = await prepareChangeSetTest(adapter1));
       });
       test("create (createEntity function w/changeSetRef)", async () => {
-        expect(block).toMatchZodSchema(BlockParagraphSchema);
+        expect(blockParagraph1).toMatchZodSchema(BlockParagraphSchema);
         expect(post).toMatchZodSchema(PostSchema);
       });
       test("read (readEntity function w/changeSetRef)", async () => {
-        const read = await changeSetAdapter.readEntity(block.ref);
+        const read = await changeSetAdapter.readEntity(blockParagraph1.ref);
         expect(read).toMatchZodSchema(BlockParagraphSchema);
       });
+      test("update (patchEntity function w/changeSetRef)", async () => {
+        const [updatedBlock] = await changeSetAdapter.updateBlockParagraph({
+          ref: blockParagraph1.ref,
+          content: "Hello, world!"
+        });
+        expect(updatedBlock).toMatchZodSchema(BlockParagraphSchema);
+      });
       test("delete (with cascade delete)", async () => {
         const [count, mutation] = await changeSetAdapter.deletePost(postRef);
         expect(count).toBe(4);
         expect(mutation.log).toStrictEqual([
-          [block.ref, "delete", draftRef],
-          [blockRow.ref, "delete", draftRef],
+          [blockParagraph1.ref, "delete", draftRef],
           [blockParagraph2.ref, "delete", draftRef],
+          [blockRow.ref, "delete", draftRef],
           [postRef, "delete", draftRef]
         ]);
+        await expect(() => changeSetAdapter.readEntity(blockParagraph1.ref)).toThrow(NotFoundError2);
+        await expect(() => changeSetAdapter.updateBlockParagraph({
+          ref: blockParagraph1.ref,
+          content: "Foo"
+        })).toThrow(NotFoundError2);
       });
-      test("update (patchEntity function w/changeSetRef)", async () => {
-        const [updatedBlock] = await changeSetAdapter.updateBlockParagraph({
-          ref: block.ref,
-          content: "Hello, world!"
+      test("pageMutations", async () => {
+        const res = await changeSetAdapter.pageMutations({
+          changeSetRef: draftRef
         });
-        expect(updatedBlock).toMatchZodSchema(BlockParagraphSchema);
+        expect(res.length).toBeGreaterThan(0);
+        expect(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
       });
-      test.skip("delete (deleteEntity function w/changeSetRef)", async () => {
-        const [updatedBlock, deleteMutation] = await changeSetAdapter.deleteBlock(block.ref);
-        expect(deleteMutation.log).toStrictEqual([
-          [postRef, "update", draftRef],
-          [block.ref, "delete", draftRef]
-        ]);
-        expect(() => changeSetAdapter.readEntity(block.ref)).toThrow(NotFoundError2);
-        expect(() => changeSetAdapter.updateBlockParagraph({
-          ref: block.ref,
-          content: "Foo"
-        })).toThrow(NotFoundError2);
+      test("pageMutations2", async () => {
+        const res = await changeSetAdapter.pageMutations({
+          changeSetRef: draftRef
+        });
+        expect(res.length).toBeGreaterThan(0);
+        expect(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
       });
     });
   };

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 * from "./operations";
+export { testAdapterImplementation } from "./testAdapterImplementation";
+export { inMemoryAdapter } from "./inMemoryAdapter";

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

@@ -0,0 +1,15 @@
+export declare const createBlockImage: import("roc-db").WriteOperation<"createBlockImage", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        postRef: `Post/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createBlockImage";
+}, {
+    postRef: `Post/${string}`;
+}, {
+    [x: string]: any;
+}>;

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

@@ -0,0 +1,15 @@
+export declare const createBlockParagrah: import("roc-db").WriteOperation<"createBlockParagraph", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createBlockParagraph";
+}, {
+    parentRef: `Post/${string}` | `BlockRow/${string}`;
+}, {
+    [x: string]: any;
+}>;

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

@@ -0,0 +1,15 @@
+export declare const createBlockRow: import("roc-db").WriteOperation<"createBlockRow", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createBlockRow";
+}, {
+    parentRef: `Post/${string}` | `BlockRow/${string}`;
+}, {
+    [x: string]: any;
+}>;

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

@@ -0,0 +1,15 @@
+export declare const createBlockTitle: import("roc-db").WriteOperation<"createBlockTitle", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createBlockTitle";
+}, {
+    parentRef: `Post/${string}` | `BlockRow/${string}`;
+}, {
+    [x: string]: any;
+}>;

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

@@ -0,0 +1,15 @@
+export declare const createDraft: import("roc-db").WriteOperation<"createDraft", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        postRef: `Post/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createDraft";
+}, {
+    postRef: `Post/${string}`;
+}, {
+    [x: string]: any;
+}>;

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

@@ -0,0 +1,19 @@
+export declare const createPost: import("roc-db").WriteOperation<"createPost", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        title: string;
+        tags: string[];
+        slug?: string | undefined;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createPost";
+}, {
+    title: string;
+    tags: string[];
+    slug?: string | undefined;
+}, {
+    [x: string]: any;
+}>;

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

@@ -0,0 +1,11 @@
+export declare const deleteBlock: import("roc-db").WriteOperation<"deleteBlock", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: `BlockImage/${string}` | `BlockParagraph/${string}`;
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "deleteBlock";
+}, `BlockImage/${string}` | `BlockParagraph/${string}`, {
+    [x: string]: any;
+}>;

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

@@ -0,0 +1,9 @@
+export declare const deletePost: import("roc-db").WriteOperation<"deletePost", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: `Post/${string}`;
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "deletePost";
+}, `Post/${string}`, any>;

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

@@ -0,0 +1,157 @@
+export declare const operations: readonly [import("roc-db").WriteOperation<"createBlockImage", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        postRef: `Post/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createBlockImage";
+}, {
+    postRef: `Post/${string}`;
+}, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<"createBlockTitle", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createBlockTitle";
+}, {
+    parentRef: `Post/${string}` | `BlockRow/${string}`;
+}, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<"createBlockParagraph", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createBlockParagraph";
+}, {
+    parentRef: `Post/${string}` | `BlockRow/${string}`;
+}, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<"createBlockRow", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createBlockRow";
+}, {
+    parentRef: `Post/${string}` | `BlockRow/${string}`;
+}, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<"createDraft", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        postRef: `Post/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createDraft";
+}, {
+    postRef: `Post/${string}`;
+}, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<"createPost", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        title: string;
+        tags: string[];
+        slug?: string | undefined;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createPost";
+}, {
+    title: string;
+    tags: string[];
+    slug?: string | undefined;
+}, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<"deleteBlock", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: `BlockImage/${string}` | `BlockParagraph/${string}`;
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "deleteBlock";
+}, `BlockImage/${string}` | `BlockParagraph/${string}`, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<"deletePost", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: `Post/${string}`;
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "deletePost";
+}, `Post/${string}`, any>, any, any, import("roc-db").WriteOperation<"updateBlockParagraph", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `BlockParagraph/${string}`;
+        content: string;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "updateBlockParagraph";
+}, {
+    ref: `BlockParagraph/${string}`;
+    content: string;
+}, `BlockParagraph/${string}`>, import("roc-db").WriteOperation<"updatePost", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Post/${string}`;
+        tags: string[];
+        title?: string | undefined;
+        authorRef?: `User/${string}` | undefined;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "updatePost";
+}, {
+    ref: `Post/${string}`;
+    tags: string[];
+    title?: string | undefined;
+    authorRef?: `User/${string}` | undefined;
+}, {
+    [x: string]: any;
+}>, import("roc-db").WriteOperation<"updatePostTitle", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Post/${string}`;
+        title: string;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "updatePostTitle";
+}, {
+    ref: `Post/${string}`;
+    title: string;
+}, {
+    [x: string]: 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/updateBlockParagraph.d.ts

@@ -0,0 +1,15 @@
+export declare const updateBlockParagraph: import("roc-db").WriteOperation<"updateBlockParagraph", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `BlockParagraph/${string}`;
+        content: string;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "updateBlockParagraph";
+}, {
+    ref: `BlockParagraph/${string}`;
+    content: string;
+}, `BlockParagraph/${string}`>;

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

@@ -0,0 +1,21 @@
+export declare const updatePost: import("roc-db").WriteOperation<"updatePost", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Post/${string}`;
+        tags: string[];
+        title?: string | undefined;
+        authorRef?: `User/${string}` | undefined;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "updatePost";
+}, {
+    ref: `Post/${string}`;
+    tags: string[];
+    title?: string | undefined;
+    authorRef?: `User/${string}` | undefined;
+}, {
+    [x: string]: any;
+}>;

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

@@ -0,0 +1,17 @@
+export declare const updatePostTitle: import("roc-db").WriteOperation<"updatePostTitle", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Post/${string}`;
+        title: string;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "updatePostTitle";
+}, {
+    ref: `Post/${string}`;
+    title: string;
+}, {
+    [x: string]: any;
+}>;

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}`>;