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

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

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

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

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

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.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 | 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 | 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.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 | 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 | undefined;
+    persistedAt?: string | null | undefined;
+}>;

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

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export declare const DeleteBlocksMutationSchema: 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>;
+    persistedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, {
+    operation: z.ZodObject<{
+        name: z.ZodLiteral<"deleteBlocks">;
+        version: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: "deleteBlocks";
+        version: number;
+    }, {
+        name: "deleteBlocks";
+        version?: number | undefined;
+    }>;
+    changeSetRef: z.ZodType<never, z.ZodTypeDef, never> | z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
+    payload: z.ZodArray<z.ZodUnion<[z.ZodType<`BlockParagraph/${string}`, z.ZodTypeDef, `BlockParagraph/${string}`>, z.ZodType<`BlockImage/${string}`, z.ZodTypeDef, `BlockImage/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>, "many">;
+    log: z.ZodType<any[], z.ZodTypeDef, any[]>;
+}>, "strict", z.ZodTypeAny, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: (`BlockImage/${string}` | `BlockParagraph/${string}` | `BlockRow/${string}`)[];
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "deleteBlocks";
+        version: number;
+    };
+    sessionRef?: string | undefined;
+    persistedAt?: string | null | undefined;
+}, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: (`BlockImage/${string}` | `BlockParagraph/${string}` | `BlockRow/${string}`)[];
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "deleteBlocks";
+        version?: number | undefined;
+    };
+    sessionRef?: string | undefined;
+    persistedAt?: string | null | undefined;
+}>;

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

@@ -0,0 +1,53 @@
+export declare const DeletePostMutationSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    ref: import("zod").ZodType<`Mutation/${string}`, import("zod").ZodTypeDef, `Mutation/${string}`>;
+    timestamp: import("zod").ZodString;
+    changeSetRef: import("zod").ZodNullable<import("zod").ZodType<never, import("zod").ZodTypeDef, never>>;
+    payload: import("zod").ZodAny;
+    log: import("zod").ZodArray<import("zod").ZodAny, "many">;
+    debounceCount: import("zod").ZodNumber;
+    identityRef: import("zod").ZodString;
+    sessionRef: import("zod").ZodOptional<import("zod").ZodString>;
+    persistedAt: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}, {
+    operation: import("zod").ZodObject<{
+        name: import("zod").ZodLiteral<"deletePost">;
+        version: import("zod").ZodDefault<import("zod").ZodNumber>;
+    }, "strip", import("zod").ZodTypeAny, {
+        name: "deletePost";
+        version: number;
+    }, {
+        name: "deletePost";
+        version?: number | undefined;
+    }>;
+    changeSetRef: import("zod").ZodType<never, import("zod").ZodTypeDef, never> | import("zod").ZodNullable<import("zod").ZodType<never, import("zod").ZodTypeDef, never>>;
+    payload: import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>;
+    log: import("zod").ZodType<any[], import("zod").ZodTypeDef, any[]>;
+}>, "strict", import("zod").ZodTypeAny, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: `Post/${string}`;
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "deletePost";
+        version: number;
+    };
+    sessionRef?: string | undefined;
+    persistedAt?: string | null | undefined;
+}, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: `Post/${string}`;
+    log: any[];
+    debounceCount: number;
+    identityRef: string;
+    operation: {
+        name: "deletePost";
+        version?: number | undefined;
+    };
+    sessionRef?: string | 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,32 @@
+import { z } from "zod";
+export declare const DraftSchema: 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/MoveBlocksMutationSchema.d.ts

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

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,33 @@
+import { z } from "zod";
+export declare const PostSchema: 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 Post = z.infer<typeof PostSchema>;

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

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

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

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