@roc-db/test-utils 0.2.0-pre.7 → 0.2.0-pre.71

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

@@ -1,15 +1,11 @@
-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";
+import { z } from "zod";
+export declare const updateBlockParagraph: import("roc-db").WriteOperation<"updateBlockParagraph", z.ZodObject<{
+    ref: z.ZodType<`BlockParagraph/${string}`, z.ZodTypeDef, `BlockParagraph/${string}`>;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    ref: `BlockParagraph/${string}`;
+    content: string;
 }, {
     ref: `BlockParagraph/${string}`;
     content: string;
-}, `BlockParagraph/${string}`>;
+}>>;

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

@@ -1,21 +1,17 @@
-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";
-}, {
+import { z } from "zod";
+export declare const updatePost: import("roc-db").WriteOperation<"updatePost", z.ZodObject<{
+    ref: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+    title: z.ZodOptional<z.ZodString>;
+    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    authorRef: z.ZodOptional<z.ZodType<`User/${string}`, z.ZodTypeDef, `User/${string}`>>;
+}, "strip", z.ZodTypeAny, {
     ref: `Post/${string}`;
     tags: string[];
     title?: string | undefined;
     authorRef?: `User/${string}` | undefined;
 }, {
-    [x: string]: any;
-}>;
+    ref: `Post/${string}`;
+    title?: string | undefined;
+    tags?: string[] | undefined;
+    authorRef?: `User/${string}` | undefined;
+}>>;

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

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const updatePostDescription: import("roc-db").WriteOperation<"updatePostDescription", z.ZodObject<{
+    ref: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    ref: `Post/${string}`;
+    description: string;
+}, {
+    ref: `Post/${string}`;
+    description: string;
+}>>;

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

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const updatePostSlug: import("roc-db").WriteOperation<"updatePostSlug", z.ZodObject<{
+    ref: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+    slug: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    ref: `Post/${string}`;
+    slug: string;
+}, {
+    ref: `Post/${string}`;
+    slug: string;
+}>>;

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

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const updatePostTags: import("roc-db").WriteOperation<"updatePostTags", z.ZodObject<{
+    ref: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+    tags: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    ref: `Post/${string}`;
+    tags: string[];
+}, {
+    ref: `Post/${string}`;
+    tags: string[];
+}>>;

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

@@ -1,17 +1,11 @@
-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";
-}, {
+import { z } from "zod";
+export declare const updatePostTitle: import("roc-db").WriteOperation<"updatePostTitle", z.ZodObject<{
+    ref: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+    title: z.ZodString;
+}, "strip", z.ZodTypeAny, {
     ref: `Post/${string}`;
     title: string;
 }, {
-    [x: string]: any;
-}>;
+    ref: `Post/${string}`;
+    title: string;
+}>>;

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
-export declare const BlockImageSchema: z.ZodObject<z.objectUtil.extendShape<{
-    ref: z.ZodType<never, z.ZodTypeDef, never>;
-    entity: z.ZodString;
+export declare const BlockImageSchema: z.ZodObject<{
+    ref: z.ZodType<`BlockImage/${string}`, z.ZodTypeDef, `BlockImage/${string}`>;
+    entity: z.ZodLiteral<"BlockImage">;
     created: z.ZodObject<{
         mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
         timestamp: z.ZodString;
@@ -22,11 +22,58 @@ export declare const BlockImageSchema: z.ZodObject<z.objectUtil.extendShape<{
         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;
+    data: z.ZodObject<{
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+    }, {
+        url: string;
+    }>;
+    children: z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>;
+    parents: z.ZodObject<{
+        post: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+    }, "strip", z.ZodTypeAny, {
+        post: `Post/${string}`;
+    }, {
+        post: `Post/${string}`;
+    }>;
+    ancestors: z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>;
+}, "strict", z.ZodTypeAny, {
+    ref: `BlockImage/${string}`;
+    data: {
+        url: string;
+    };
+    parents: {
+        post: `Post/${string}`;
+    };
+    entity: "BlockImage";
+    created: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    updated: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    children: {};
+    ancestors: {};
 }, {
-    [x: string]: any;
+    ref: `BlockImage/${string}`;
+    data: {
+        url: string;
+    };
+    parents: {
+        post: `Post/${string}`;
+    };
+    entity: "BlockImage";
+    created: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    updated: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    children: {};
+    ancestors: {};
 }>;

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
-export declare const BlockParagraphSchema: z.ZodObject<z.objectUtil.extendShape<{
-    ref: z.ZodType<never, z.ZodTypeDef, never>;
-    entity: z.ZodString;
+export declare const BlockParagraphSchema: z.ZodObject<{
+    ref: z.ZodType<`BlockParagraph/${string}`, z.ZodTypeDef, `BlockParagraph/${string}`>;
+    entity: z.ZodLiteral<"BlockParagraph">;
     created: z.ZodObject<{
         mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
         timestamp: z.ZodString;
@@ -22,12 +22,59 @@ export declare const BlockParagraphSchema: z.ZodObject<z.objectUtil.extendShape<
         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;
+    data: z.ZodObject<{
+        content: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content?: string | undefined;
+    }, {
+        content?: string | undefined;
+    }>;
+    children: z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>;
+    parents: z.ZodObject<{
+        parent: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+    }, "strip", z.ZodTypeAny, {
+        parent: `Post/${string}`;
+    }, {
+        parent: `Post/${string}`;
+    }>;
+    ancestors: z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>;
+}, "strict", z.ZodTypeAny, {
+    ref: `BlockParagraph/${string}`;
+    data: {
+        content?: string | undefined;
+    };
+    parents: {
+        parent: `Post/${string}`;
+    };
+    entity: "BlockParagraph";
+    created: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    updated: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    children: {};
+    ancestors: {};
 }, {
-    [x: string]: any;
+    ref: `BlockParagraph/${string}`;
+    data: {
+        content?: string | undefined;
+    };
+    parents: {
+        parent: `Post/${string}`;
+    };
+    entity: "BlockParagraph";
+    created: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    updated: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    children: {};
+    ancestors: {};
 }>;
 export type BlockParagraph = z.infer<typeof BlockParagraphSchema>;

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
-export declare const BlockRowSchema: z.ZodObject<z.objectUtil.extendShape<{
-    ref: z.ZodType<never, z.ZodTypeDef, never>;
-    entity: z.ZodString;
+export declare const BlockRowSchema: z.ZodObject<{
+    ref: z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>;
+    entity: z.ZodLiteral<"BlockRow">;
     created: z.ZodObject<{
         mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
         timestamp: z.ZodString;
@@ -22,12 +22,64 @@ export declare const BlockRowSchema: z.ZodObject<z.objectUtil.extendShape<{
         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;
+    data: z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>;
+    children: z.ZodObject<{
+        blocks: z.ZodArray<z.ZodUnion<[z.ZodType<`BlockParagraph/${string}`, z.ZodTypeDef, `BlockParagraph/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        blocks: (`BlockParagraph/${string}` | `BlockRow/${string}`)[];
+    }, {
+        blocks: (`BlockParagraph/${string}` | `BlockRow/${string}`)[];
+    }>;
+    parents: z.ZodObject<{
+        post: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+        block: z.ZodUnion<[z.ZodType<`BlockParagraph/${string}`, z.ZodTypeDef, `BlockParagraph/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>;
+    }, "strip", z.ZodTypeAny, {
+        post: `Post/${string}`;
+        block: `BlockParagraph/${string}` | `BlockRow/${string}`;
+    }, {
+        post: `Post/${string}`;
+        block: `BlockParagraph/${string}` | `BlockRow/${string}`;
+    }>;
+    ancestors: z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>;
+}, "strict", z.ZodTypeAny, {
+    ref: `BlockRow/${string}`;
+    data: {};
+    parents: {
+        post: `Post/${string}`;
+        block: `BlockParagraph/${string}` | `BlockRow/${string}`;
+    };
+    entity: "BlockRow";
+    created: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    updated: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    children: {
+        blocks: (`BlockParagraph/${string}` | `BlockRow/${string}`)[];
+    };
+    ancestors: {};
 }, {
-    [x: string]: any;
+    ref: `BlockRow/${string}`;
+    data: {};
+    parents: {
+        post: `Post/${string}`;
+        block: `BlockParagraph/${string}` | `BlockRow/${string}`;
+    };
+    entity: "BlockRow";
+    created: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    updated: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    children: {
+        blocks: (`BlockParagraph/${string}` | `BlockRow/${string}`)[];
+    };
+    ancestors: {};
 }>;
 export type BlockRow = z.infer<typeof BlockRowSchema>;

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
-export declare const BlockTitleSchema: z.ZodObject<z.objectUtil.extendShape<{
-    ref: z.ZodType<never, z.ZodTypeDef, never>;
-    entity: z.ZodString;
+export declare const BlockTitleSchema: z.ZodObject<{
+    ref: z.ZodType<`BlockTitle/${string}`, z.ZodTypeDef, `BlockTitle/${string}`>;
+    entity: z.ZodLiteral<"BlockTitle">;
     created: z.ZodObject<{
         mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
         timestamp: z.ZodString;
@@ -22,11 +22,58 @@ export declare const BlockTitleSchema: z.ZodObject<z.objectUtil.extendShape<{
         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;
+    data: z.ZodObject<{
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+    }, {
+        content: string;
+    }>;
+    children: z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>;
+    parents: z.ZodObject<{
+        post: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+    }, "strip", z.ZodTypeAny, {
+        post: `Post/${string}`;
+    }, {
+        post: `Post/${string}`;
+    }>;
+    ancestors: z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>;
+}, "strict", z.ZodTypeAny, {
+    ref: `BlockTitle/${string}`;
+    data: {
+        content: string;
+    };
+    parents: {
+        post: `Post/${string}`;
+    };
+    entity: "BlockTitle";
+    created: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    updated: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    children: {};
+    ancestors: {};
 }, {
-    [x: string]: any;
+    ref: `BlockTitle/${string}`;
+    data: {
+        content: string;
+    };
+    parents: {
+        post: `Post/${string}`;
+    };
+    entity: "BlockTitle";
+    created: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    updated: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    children: {};
+    ancestors: {};
 }>;

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

@@ -4,10 +4,22 @@ export declare const CreatePostMutationSchema: z.ZodObject<z.objectUtil.extendSh
     timestamp: z.ZodString;
     changeSetRef: z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
     payload: z.ZodAny;
-    log: z.ZodArray<z.ZodTuple<[z.ZodType<never, z.ZodTypeDef, never>, z.ZodString, z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>], null>, "many">;
+    log: z.ZodArray<z.ZodAny, "many">;
     debounceCount: z.ZodNumber;
+    identityRef: z.ZodString;
+    sessionRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    persistedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, {
-    name: z.ZodLiteral<"createPost">;
+    operation: z.ZodObject<{
+        name: z.ZodLiteral<"createPost">;
+        version: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: "createPost";
+        version: number;
+    }, {
+        name: "createPost";
+        version?: number | undefined;
+    }>;
     changeSetRef: z.ZodType<never, z.ZodTypeDef, never> | z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
     payload: z.ZodObject<{
         title: z.ZodString;
@@ -22,7 +34,7 @@ export declare const CreatePostMutationSchema: z.ZodObject<z.objectUtil.extendSh
         tags?: string[] | undefined;
         slug?: string | undefined;
     }>;
-    log: z.ZodType<[never, string, null][], z.ZodTypeDef, [never, string, null][]>;
+    log: z.ZodType<any[], z.ZodTypeDef, any[]>;
 }>, "strict", z.ZodTypeAny, {
     ref: `Mutation/${string}`;
     timestamp: string;
@@ -32,9 +44,15 @@ export declare const CreatePostMutationSchema: z.ZodObject<z.objectUtil.extendSh
         tags: string[];
         slug?: string | undefined;
     };
-    log: [never, string, null][];
+    log: any[];
     debounceCount: number;
-    name: "createPost";
+    identityRef: string;
+    operation: {
+        name: "createPost";
+        version: number;
+    };
+    sessionRef?: string | null | undefined;
+    persistedAt?: string | null | undefined;
 }, {
     ref: `Mutation/${string}`;
     timestamp: string;
@@ -44,7 +62,13 @@ export declare const CreatePostMutationSchema: z.ZodObject<z.objectUtil.extendSh
         tags?: string[] | undefined;
         slug?: string | undefined;
     };
-    log: [never, string, null][];
+    log: any[];
     debounceCount: number;
-    name: "createPost";
+    identityRef: string;
+    operation: {
+        name: "createPost";
+        version?: number | undefined;
+    };
+    sessionRef?: string | null | undefined;
+    persistedAt?: string | null | undefined;
 }>;

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

@@ -4,10 +4,22 @@ export declare const CreateUserMutationSchema: z.ZodObject<z.objectUtil.extendSh
     timestamp: z.ZodString;
     changeSetRef: z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
     payload: z.ZodAny;
-    log: z.ZodArray<z.ZodTuple<[z.ZodType<never, z.ZodTypeDef, never>, z.ZodString, z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>], null>, "many">;
+    log: z.ZodArray<z.ZodAny, "many">;
     debounceCount: z.ZodNumber;
+    identityRef: z.ZodString;
+    sessionRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    persistedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, {
-    name: z.ZodLiteral<"createUser">;
+    operation: z.ZodObject<{
+        name: z.ZodLiteral<"createUser">;
+        version: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: "createUser";
+        version: number;
+    }, {
+        name: "createUser";
+        version?: number | undefined;
+    }>;
     changeSetRef: z.ZodType<never, z.ZodTypeDef, never> | z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
     payload: z.ZodObject<{
         email: z.ZodString;
@@ -16,7 +28,7 @@ export declare const CreateUserMutationSchema: z.ZodObject<z.objectUtil.extendSh
     }, {
         email: string;
     }>;
-    log: z.ZodType<[never, string, null][], z.ZodTypeDef, [never, string, null][]>;
+    log: z.ZodType<any[], z.ZodTypeDef, any[]>;
 }>, "strict", z.ZodTypeAny, {
     ref: `Mutation/${string}`;
     timestamp: string;
@@ -24,9 +36,15 @@ export declare const CreateUserMutationSchema: z.ZodObject<z.objectUtil.extendSh
     payload: {
         email: string;
     };
-    log: [never, string, null][];
+    log: any[];
     debounceCount: number;
-    name: "createUser";
+    identityRef: string;
+    operation: {
+        name: "createUser";
+        version: number;
+    };
+    sessionRef?: string | null | undefined;
+    persistedAt?: string | null | undefined;
 }, {
     ref: `Mutation/${string}`;
     timestamp: string;
@@ -34,7 +52,13 @@ export declare const CreateUserMutationSchema: z.ZodObject<z.objectUtil.extendSh
     payload: {
         email: string;
     };
-    log: [never, string, null][];
+    log: any[];
     debounceCount: number;
-    name: "createUser";
+    identityRef: string;
+    operation: {
+        name: "createUser";
+        version?: number | undefined;
+    };
+    sessionRef?: string | null | undefined;
+    persistedAt?: string | null | undefined;
 }>;

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
-export declare const DraftSchema: z.ZodObject<z.objectUtil.extendShape<{
-    ref: z.ZodType<never, z.ZodTypeDef, never>;
-    entity: z.ZodString;
+export declare const DraftSchema: z.ZodObject<{
+    ref: z.ZodType<`Draft/${string}`, z.ZodTypeDef, `Draft/${string}`>;
+    entity: z.ZodLiteral<"Draft">;
     created: z.ZodObject<{
         mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
         timestamp: z.ZodString;
@@ -22,11 +22,48 @@ export declare const DraftSchema: z.ZodObject<z.objectUtil.extendShape<{
         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;
+    data: z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>;
+    children: z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>;
+    parents: z.ZodObject<{
+        post: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+    }, "strip", z.ZodTypeAny, {
+        post: `Post/${string}`;
+    }, {
+        post: `Post/${string}`;
+    }>;
+    ancestors: z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>;
+}, "strict", z.ZodTypeAny, {
+    ref: `Draft/${string}`;
+    data: {};
+    parents: {
+        post: `Post/${string}`;
+    };
+    entity: "Draft";
+    created: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    updated: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    children: {};
+    ancestors: {};
 }, {
-    [x: string]: any;
+    ref: `Draft/${string}`;
+    data: {};
+    parents: {
+        post: `Post/${string}`;
+    };
+    entity: "Draft";
+    created: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    updated: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    children: {};
+    ancestors: {};
 }>;