@roc-db/test-utils 0.2.0-pre.6 → 0.2.0-pre.60

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,85 @@
+import { z } from "zod";
+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;
+    }, "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<{}, 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: {};
+}, {
+    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/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,79 @@
+import { z } from "zod";
+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;
+    }, "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<{
+        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: {};
+}, {
+    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

@@ -0,0 +1,74 @@
+import { z } from "zod";
+export declare const CreatePostMutationSchema: 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.ZodNullable<z.ZodString>>;
+    persistedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, {
+    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;
+        slug: z.ZodOptional<z.ZodString>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        title: string;
+        tags: string[];
+        slug?: string | undefined;
+    }, {
+        title: string;
+        tags?: string[] | undefined;
+        slug?: string | undefined;
+    }>;
+    log: z.ZodType<any[], z.ZodTypeDef, any[]>;
+}>, "strict", z.ZodTypeAny, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        title: string;
+        tags: string[];
+        slug?: string | undefined;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "createPost";
+        version: number;
+    };
+    sessionRef?: string | null | undefined;
+    persistedAt?: string | null | undefined;
+}, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        title: string;
+        tags?: string[] | undefined;
+        slug?: string | undefined;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "createPost";
+        version?: number | undefined;
+    };
+    sessionRef?: string | null | undefined;
+    persistedAt?: string | null | undefined;
+}>;

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

@@ -0,0 +1,64 @@
+import { z } from "zod";
+export declare const CreateUserMutationSchema: 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.ZodNullable<z.ZodString>>;
+    persistedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, {
+    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;
+    }, "strip", z.ZodTypeAny, {
+        email: string;
+    }, {
+        email: string;
+    }>;
+    log: z.ZodType<any[], z.ZodTypeDef, any[]>;
+}>, "strict", z.ZodTypeAny, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        email: string;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "createUser";
+        version: number;
+    };
+    sessionRef?: string | null | undefined;
+    persistedAt?: string | null | undefined;
+}, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        email: string;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "createUser";
+        version?: number | undefined;
+    };
+    sessionRef?: string | null | undefined;
+    persistedAt?: string | null | undefined;
+}>;

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

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

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

@@ -0,0 +1,69 @@
+import { z } from "zod";
+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;
+    }, "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<{}, 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: {};
+}, {
+    ref: `Draft/${string}`;
+    data: {};
+    parents: {
+        post: `Post/${string}`;
+    };
+    entity: "Draft";
+    created: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    updated: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    children: {};
+    ancestors: {};
+}>;

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

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

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

@@ -0,0 +1,105 @@
+import { z } from "zod";
+export declare const PostSchema: z.ZodObject<{
+    ref: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+    entity: z.ZodLiteral<"Post">;
+    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<{
+        title: z.ZodString;
+        text: z.ZodOptional<z.ZodString>;
+        tags: z.ZodArray<z.ZodString, "many">;
+        slug: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        tags: string[];
+        text?: string | undefined;
+        slug?: string | undefined;
+    }, {
+        title: string;
+        tags: string[];
+        text?: string | undefined;
+        slug?: string | undefined;
+    }>;
+    children: z.ZodObject<{
+        blocks: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        blocks: string[];
+    }, {
+        blocks: string[];
+    }>;
+    parents: z.ZodObject<{
+        author: z.ZodOptional<z.ZodType<`User/${string}`, z.ZodTypeDef, `User/${string}`>>;
+    }, "strip", z.ZodTypeAny, {
+        author?: `User/${string}` | undefined;
+    }, {
+        author?: `User/${string}` | undefined;
+    }>;
+    ancestors: z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>;
+}, "strict", z.ZodTypeAny, {
+    ref: `Post/${string}`;
+    data: {
+        title: string;
+        tags: string[];
+        text?: string | undefined;
+        slug?: string | undefined;
+    };
+    parents: {
+        author?: `User/${string}` | undefined;
+    };
+    entity: "Post";
+    created: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    updated: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    children: {
+        blocks: string[];
+    };
+    ancestors: {};
+}, {
+    ref: `Post/${string}`;
+    data: {
+        title: string;
+        tags: string[];
+        text?: string | undefined;
+        slug?: string | undefined;
+    };
+    parents: {
+        author?: `User/${string}` | undefined;
+    };
+    entity: "Post";
+    created: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    updated: {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    };
+    children: {
+        blocks: string[];
+    };
+    ancestors: {};
+}>;
+export type Post = z.infer<typeof PostSchema>;

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

@@ -0,0 +1,79 @@
+import { z } from "zod";
+export declare const UpdatePostMutationSchema: 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.ZodNullable<z.ZodString>>;
+    persistedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, {
+    operation: z.ZodObject<{
+        name: z.ZodLiteral<"updatePost">;
+        version: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: "updatePost";
+        version: number;
+    }, {
+        name: "updatePost";
+        version?: number | undefined;
+    }>;
+    changeSetRef: z.ZodType<never, z.ZodTypeDef, never> | z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
+    payload: 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;
+    }, {
+        ref: `Post/${string}`;
+        title?: string | undefined;
+        tags?: string[] | undefined;
+        authorRef?: `User/${string}` | undefined;
+    }>;
+    log: z.ZodType<any[], z.ZodTypeDef, any[]>;
+}>, "strict", z.ZodTypeAny, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Post/${string}`;
+        tags: string[];
+        title?: string | undefined;
+        authorRef?: `User/${string}` | undefined;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "updatePost";
+        version: number;
+    };
+    sessionRef?: string | null | undefined;
+    persistedAt?: string | null | undefined;
+}, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Post/${string}`;
+        title?: string | undefined;
+        tags?: string[] | undefined;
+        authorRef?: `User/${string}` | undefined;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "updatePost";
+        version?: number | undefined;
+    };
+    sessionRef?: string | null | undefined;
+    persistedAt?: string | null | undefined;
+}>;

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

@@ -0,0 +1,69 @@
+import { z } from "zod";
+export declare const UpdatePostTitleMutationSchema: 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.ZodNullable<z.ZodString>>;
+    persistedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, {
+    operation: z.ZodObject<{
+        name: z.ZodLiteral<"updatePostTitle">;
+        version: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: "updatePostTitle";
+        version: number;
+    }, {
+        name: "updatePostTitle";
+        version?: number | undefined;
+    }>;
+    changeSetRef: z.ZodType<never, z.ZodTypeDef, never> | z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
+    payload: z.ZodObject<{
+        ref: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+        title: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        ref: `Post/${string}`;
+        title: string;
+    }, {
+        ref: `Post/${string}`;
+        title: string;
+    }>;
+    log: z.ZodType<any[], z.ZodTypeDef, any[]>;
+}>, "strict", z.ZodTypeAny, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Post/${string}`;
+        title: string;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "updatePostTitle";
+        version: number;
+    };
+    sessionRef?: string | null | undefined;
+    persistedAt?: string | null | undefined;
+}, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Post/${string}`;
+        title: string;
+    };
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "updatePostTitle";
+        version?: number | undefined;
+    };
+    sessionRef?: string | null | undefined;
+    persistedAt?: string | null | undefined;
+}>;

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

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

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

@@ -0,0 +1,13 @@
+import { BlockImageSchema } from "./BlockImageSchema";
+import { BlockParagraphSchema } from "./BlockParagraphSchema";
+import { BlockTitleSchema } from "./BlockTitleSchema";
+import { DraftSchema } from "./DraftSchema";
+import { PostSchema } from "./PostSchema";
+export { BlockImageSchema, BlockParagraphSchema, BlockTitleSchema, DraftSchema, PostSchema, };
+export { DraftRefSchema } from "./DraftRefSchema";
+export { PostRefSchema } from "./PostRefSchema";
+export { UserRefSchema } from "./UserRefSchema";
+export { CreatePostMutationSchema } from "./CreatePostMutationSchema";
+export { CreateUserMutationSchema } from "./CreateUserMutationSchema";
+export { UpdatePostMutationSchema } from "./UpdatePostMutationSchema";
+export { UpdatePostTitleMutationSchema } from "./UpdatePostTitleMutationSchema";

package/dist/types/testAdapterImplementation.d.ts

@@ -0,0 +1 @@
+export declare const testAdapterImplementation: <EngineOptions extends {}>(adapterConstructor: any, generateArgs: () => EngineOptions) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@roc-db/test-utils",
-    "version": "0.2.0-pre.6",
+    "version": "0.2.0-pre.60",
     "type": "module",
     "exports": {
         ".": {
@@ -17,7 +17,7 @@
     ],
     "sideEffects": false,
     "peerDependencies": {
-        "roc-db": "0.2.0-pre.6",
+        "roc-db": "0.2.0-pre.60",
         "zod": "3.24.2"
     },
     "keywords": [],