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

package/dist/types/entities/BlockImageEntity.d.ts

@@ -0,0 +1,7 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const BlockImageEntity: Entity<"BlockImage", z.ZodObject<{
+    url: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    parent: z.ZodTemplateLiteral<`Post/${number}`>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

package/dist/types/entities/BlockParagraph.d.ts

@@ -0,0 +1,7 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const BlockParagraph: Entity<"BlockParagraph", z.ZodObject<{
+    content: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    parent: z.ZodUnion<readonly [z.ZodType<`Post/${number}`, `Post/${number}`, z.core.$ZodTypeInternals<`Post/${number}`, `Post/${number}`>>, z.ZodUnion<readonly [z.ZodTemplateLiteral<`BlockParagraph/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>]>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

package/dist/types/entities/BlockRow.d.ts

@@ -0,0 +1,7 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const BlockRow: Entity<"BlockRow", z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    blocks: z.ZodArray<z.ZodUnion<readonly [z.ZodTemplateLiteral<`BlockParagraph/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    parent: z.ZodUnion<readonly [z.ZodType<`Post/${number}`, `Post/${number}`, z.core.$ZodTypeInternals<`Post/${number}`, `Post/${number}`>>, z.ZodUnion<readonly [z.ZodTemplateLiteral<`BlockParagraph/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>]>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

package/dist/types/entities/Draft.d.ts

@@ -0,0 +1,8 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const Draft: Entity<"Draft", z.ZodObject<{
+    appliedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    post: z.ZodTemplateLiteral<`Post/${number}`>;
+    version: z.ZodOptional<z.ZodTemplateLiteral<`PostVersion/${number}`>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

package/dist/types/entities/OrgSettingsEntity.d.ts

@@ -0,0 +1,10 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const OrgSettingsEntity: Entity<"OrgSettings", z.ZodObject<{
+    name: z.ZodString;
+    theme: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    featuredPosts: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    primaryAdmin: z.ZodOptional<z.ZodTemplateLiteral<`User/${number}`>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, true>;

package/dist/types/entities/PostEntity.d.ts

@@ -0,0 +1,12 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const PostEntity: Entity<"Post", z.ZodObject<{
+    title: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
+    tags: z.ZodArray<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    blocks: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    author: z.ZodOptional<z.ZodTemplateLiteral<`User/${number}`>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

package/dist/types/entities/PostVersion.d.ts

@@ -0,0 +1,8 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const PostVersion: Entity<"PostVersion", z.ZodObject<{
+    version: z.ZodNumber;
+    snapshot: z.ZodArray<z.ZodAny>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    post: z.ZodTemplateLiteral<`Post/${number}`>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

package/dist/types/entities/UserEntity.d.ts

@@ -0,0 +1,5 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const UserEntity: Entity<"User", z.ZodObject<{
+    email: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

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

@@ -0,0 +1,41 @@
+export declare const entities: (import("roc-db").Entity<"Draft", import("zod").ZodObject<{
+    appliedAt: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    post: import("zod").ZodTemplateLiteral<`Post/${number}`>;
+    version: import("zod").ZodOptional<import("zod").ZodTemplateLiteral<`PostVersion/${number}`>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false> | import("roc-db").Entity<"BlockImage", import("zod").ZodObject<{
+    url: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    parent: import("zod").ZodTemplateLiteral<`Post/${number}`>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false> | import("roc-db").Entity<"Post", import("zod").ZodObject<{
+    title: import("zod").ZodString;
+    text: import("zod").ZodOptional<import("zod").ZodString>;
+    tags: import("zod").ZodArray<import("zod").ZodString>;
+    slug: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    blocks: import("zod").ZodArray<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    author: import("zod").ZodOptional<import("zod").ZodTemplateLiteral<`User/${number}`>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false> | import("roc-db").Entity<"BlockParagraph", import("zod").ZodObject<{
+    content: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    parent: import("zod").ZodUnion<readonly [import("zod").ZodType<`Post/${number}`, `Post/${number}`, import("zod/v4/core").$ZodTypeInternals<`Post/${number}`, `Post/${number}`>>, import("zod").ZodUnion<readonly [import("zod").ZodTemplateLiteral<`BlockParagraph/${number}`>, import("zod").ZodTemplateLiteral<`BlockRow/${number}`>]>]>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false> | import("roc-db").Entity<"BlockRow", import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    blocks: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodTemplateLiteral<`BlockParagraph/${number}`>, import("zod").ZodTemplateLiteral<`BlockRow/${number}`>]>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    parent: import("zod").ZodUnion<readonly [import("zod").ZodType<`Post/${number}`, `Post/${number}`, import("zod/v4/core").$ZodTypeInternals<`Post/${number}`, `Post/${number}`>>, import("zod").ZodUnion<readonly [import("zod").ZodTemplateLiteral<`BlockParagraph/${number}`>, import("zod").ZodTemplateLiteral<`BlockRow/${number}`>]>]>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false> | import("roc-db").Entity<"OrgSettings", import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    theme: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    featuredPosts: import("zod").ZodArray<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    primaryAdmin: import("zod").ZodOptional<import("zod").ZodTemplateLiteral<`User/${number}`>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, true> | import("roc-db").Entity<"PostVersion", import("zod").ZodObject<{
+    version: import("zod").ZodNumber;
+    snapshot: import("zod").ZodArray<import("zod").ZodAny>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    post: import("zod").ZodTemplateLiteral<`Post/${number}`>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false> | import("roc-db").Entity<"User", import("zod").ZodObject<{
+    email: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false>)[];

package/dist/types/inMemoryAdapter.d.ts

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

package/dist/types/index.d.ts

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

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

@@ -0,0 +1 @@
+export declare const applyDraft: import("roc-db").WriteOperation<"applyDraft", import("zod").ZodType<`Draft/${number}`, `Draft/${number}`, import("zod/v4/core").$ZodTypeInternals<`Draft/${number}`, `Draft/${number}`>>>;

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

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const createBlockImage: import("roc-db").WriteOperation<"createBlockImage", z.ZodObject<{
+    parentRef: z.ZodTemplateLiteral<`Post/${number}`>;
+    url: z.ZodString;
+}, z.core.$strict>>;

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

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const createBlockParagrah: import("roc-db").WriteOperation<"createBlockParagraph", z.ZodObject<{
+    parentRef: z.ZodUnion<readonly [z.ZodTemplateLiteral<`Post/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>;
+    content: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;

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

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const createBlockRow: import("roc-db").WriteOperation<"createBlockRow", z.ZodObject<{
+    parentRef: z.ZodUnion<readonly [z.ZodTemplateLiteral<`Post/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>;
+}, z.core.$strict>>;

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

@@ -0,0 +1,13 @@
+import { z } from "zod";
+/**
+ * Like `createBlockRow`, but it reads its own changeSet root before creating the
+ * block — a common "validate/attach against the changeSet root" pattern. When a
+ * mutation of this op is cloned into a freshly-created target and replayed, that
+ * read resolves the TARGET root. In the one-transaction duplicate pattern the
+ * target root is created (uncommitted) by the same outer operation, so the
+ * primitive must surface the outer transaction's pending writes to replay —
+ * otherwise this read throws NotFoundError for the target changeSet ref.
+ */
+export declare const createBlockRowReadingRoot: import("roc-db").WriteOperation<"createBlockRowReadingRoot", z.ZodObject<{
+    parentRef: z.ZodUnion<readonly [z.ZodTemplateLiteral<`Post/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>;
+}, z.core.$strict>>;

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

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const createBlockTitle: import("roc-db").WriteOperation<"createBlockTitle", z.ZodObject<{
+    parentRef: z.ZodUnion<readonly [z.ZodTemplateLiteral<`Post/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>;
+}, z.core.$strict>>;

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

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const createDraft: import("roc-db").WriteOperation<"createDraft", z.ZodObject<{
+    postRef: z.ZodTemplateLiteral<`Post/${number}`>;
+}, z.core.$strict>>;

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

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const createOrgSettings: import("roc-db").WriteOperation<"createOrgSettings", z.ZodObject<{
+    name: z.ZodString;
+    theme: z.ZodOptional<z.ZodString>;
+    primaryAdmin: z.ZodOptional<z.ZodTemplateLiteral<`User/${number}`>>;
+}, z.core.$strip>>;

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

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const createPost: import("roc-db").WriteOperation<"createPost", z.ZodObject<{
+    title: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>>;

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare const createUnknownRef: import("roc-db").WriteOperation<"createUnknownRef", z.ZodOptional<z.ZodObject<{}, z.core.$strip>>>;

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

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const createUser: import("roc-db").WriteOperation<"createUser", z.ZodObject<{
+    email: z.ZodString;
+}, z.core.$strip>>;

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

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const crudBySlug: import("roc-db").WriteOperation<"crudBySlug", z.ZodObject<{
+    slug: z.ZodString;
+    newSlug: z.ZodString;
+}, z.core.$strip>>;

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare const deleteBlocks: import("roc-db").WriteOperation<"deleteBlocks", z.ZodArray<z.ZodUnion<readonly [z.ZodTemplateLiteral<`BlockParagraph/${number}`>, z.ZodTemplateLiteral<`BlockImage/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>>>;

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

@@ -0,0 +1 @@
+export declare const deleteDraft: import("roc-db").WriteOperation<"deleteDraft", import("zod").ZodType<`Draft/${number}`, `Draft/${number}`, import("zod/v4/core").$ZodTypeInternals<`Draft/${number}`, `Draft/${number}`>>>;

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare const deleteOrgSettings: import("roc-db").WriteOperation<"deleteOrgSettings", z.ZodOptional<z.ZodObject<{}, z.core.$strip>>>;

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

@@ -0,0 +1 @@
+export declare const deletePost: import("roc-db").WriteOperation<"deletePost", import("zod").ZodTemplateLiteral<`Post/${number}`>>;

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

@@ -0,0 +1,10 @@
+import { z } from "zod";
+/**
+ * Canonical consumer usage of the `txn.duplicateChangeSetMutations` primitive:
+ * create the new draft and copy the source draft's pending mutations into it,
+ * all in one transaction.
+ */
+export declare const duplicateDraft: import("roc-db").WriteOperation<"duplicateDraft", z.ZodObject<{
+    sourceRef: z.ZodType<`Draft/${number}`, `Draft/${number}`, z.core.$ZodTypeInternals<`Draft/${number}`, `Draft/${number}`>>;
+    postRef: z.ZodTemplateLiteral<`Post/${number}`>;
+}, z.core.$strict>>;

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

@@ -0,0 +1 @@
+export declare const operations: any[];

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

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const moveBlocks: import("roc-db").WriteOperation<"moveBlocks", z.ZodObject<{
+    refs: z.ZodArray<z.ZodUnion<readonly [z.ZodTemplateLiteral<`BlockParagraph/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>>;
+    targetPosition: z.ZodNumber;
+}, z.core.$strict>>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare const readOrgSettings: import("roc-db").ReadOperation<"readOrgSettings", z.ZodOptional<z.ZodObject<{}, z.core.$strip>>>;

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const testTransactionalEdits: import("roc-db").WriteOperation<"testTransactionalEdits", z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    post1ref: z.ZodOptional<z.ZodTemplateLiteral<`Post/${number}`>>;
+    post2ref: z.ZodOptional<z.ZodTemplateLiteral<`Post/${number}`>>;
+}, z.core.$strict>>;

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

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const updateBlockParagraph: import("roc-db").WriteOperation<"updateBlockParagraph", z.ZodObject<{
+    ref: z.ZodTemplateLiteral<`BlockParagraph/${number}`>;
+    content: z.ZodString;
+}, z.core.$strip>>;

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

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const updateOrgSettingsName: import("roc-db").WriteOperation<"updateOrgSettingsName", z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>>;

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

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const updatePost: import("roc-db").WriteOperation<"updatePost", z.ZodObject<{
+    ref: z.ZodTemplateLiteral<`Post/${number}`>;
+    title: z.ZodOptional<z.ZodString>;
+    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    authorRef: z.ZodOptional<z.ZodTemplateLiteral<`User/${number}`>>;
+}, z.core.$strip>>;

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

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

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

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

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

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const updatePostTags: import("roc-db").WriteOperation<"updatePostTags", z.ZodObject<{
+    ref: z.ZodTemplateLiteral<`Post/${number}`>;
+    tags: z.ZodArray<z.ZodString>;
+}, z.core.$strip>>;

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

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const updatePostTitle: import("roc-db").WriteOperation<"updatePostTitle", z.ZodObject<{
+    ref: z.ZodTemplateLiteral<`Post/${number}`>;
+    title: z.ZodString;
+}, z.core.$strip>>;

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

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

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const BlockImageSchema: z.ZodObject<{
+    ref: z.ZodNonOptional<z.ZodTemplateLiteral<`BlockImage/${number}`>>;
+    entity: z.ZodNonOptional<z.ZodLiteral<"BlockImage">>;
+    created: z.ZodNonOptional<z.ZodObject<{
+        mutationRef: z.ZodNonOptional<z.ZodTemplateLiteral<`Mutation/${number}`>>;
+        timestamp: z.ZodNonOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    updated: z.ZodNonOptional<z.ZodObject<{
+        mutationRef: z.ZodNonOptional<z.ZodTemplateLiteral<`Mutation/${number}`>>;
+        timestamp: z.ZodNonOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    data: z.ZodNonOptional<z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strip>>;
+    children: z.ZodNonOptional<z.ZodObject<{}, z.core.$strip>>;
+    parents: z.ZodNonOptional<z.ZodObject<{
+        post: z.ZodTemplateLiteral<`Post/${number}`>;
+    }, z.core.$strip>>;
+    ancestors: z.ZodNonOptional<z.ZodObject<{}, z.core.$strip>>;
+}, z.core.$strict>;

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

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

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

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export declare const BlockParagraphSchema: z.ZodObject<{
+    ref: z.ZodNonOptional<z.ZodTemplateLiteral<`BlockParagraph/${number}`>>;
+    entity: z.ZodNonOptional<z.ZodLiteral<"BlockParagraph">>;
+    created: z.ZodNonOptional<z.ZodObject<{
+        mutationRef: z.ZodNonOptional<z.ZodTemplateLiteral<`Mutation/${number}`>>;
+        timestamp: z.ZodNonOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    updated: z.ZodNonOptional<z.ZodObject<{
+        mutationRef: z.ZodNonOptional<z.ZodTemplateLiteral<`Mutation/${number}`>>;
+        timestamp: z.ZodNonOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    data: z.ZodNonOptional<z.ZodObject<{
+        content: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    children: z.ZodNonOptional<z.ZodObject<{}, z.core.$strip>>;
+    parents: z.ZodNonOptional<z.ZodObject<{
+        parent: z.ZodTemplateLiteral<`Post/${number}`>;
+    }, z.core.$strip>>;
+    ancestors: z.ZodNonOptional<z.ZodObject<{}, z.core.$strip>>;
+}, z.core.$strict>;
+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<readonly [z.ZodTemplateLiteral<`BlockParagraph/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>;

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

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

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export declare const BlockRowSchema: z.ZodObject<{
+    ref: z.ZodNonOptional<z.ZodTemplateLiteral<`BlockRow/${number}`>>;
+    entity: z.ZodNonOptional<z.ZodLiteral<"BlockRow">>;
+    created: z.ZodNonOptional<z.ZodObject<{
+        mutationRef: z.ZodNonOptional<z.ZodTemplateLiteral<`Mutation/${number}`>>;
+        timestamp: z.ZodNonOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    updated: z.ZodNonOptional<z.ZodObject<{
+        mutationRef: z.ZodNonOptional<z.ZodTemplateLiteral<`Mutation/${number}`>>;
+        timestamp: z.ZodNonOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    data: z.ZodNonOptional<z.ZodObject<{}, z.core.$strip>>;
+    children: z.ZodNonOptional<z.ZodObject<{
+        blocks: z.ZodArray<z.ZodUnion<readonly [z.ZodTemplateLiteral<`BlockParagraph/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>>;
+    }, z.core.$strip>>;
+    parents: z.ZodNonOptional<z.ZodObject<{
+        post: z.ZodTemplateLiteral<`Post/${number}`>;
+        block: z.ZodUnion<readonly [z.ZodTemplateLiteral<`BlockParagraph/${number}`>, z.ZodTemplateLiteral<`BlockRow/${number}`>]>;
+    }, z.core.$strip>>;
+    ancestors: z.ZodNonOptional<z.ZodObject<{}, z.core.$strip>>;
+}, z.core.$strict>;
+export type BlockRow = z.infer<typeof BlockRowSchema>;

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const BlockTitleSchema: z.ZodObject<{
+    ref: z.ZodNonOptional<z.ZodTemplateLiteral<`BlockTitle/${number}`>>;
+    entity: z.ZodNonOptional<z.ZodLiteral<"BlockTitle">>;
+    created: z.ZodNonOptional<z.ZodObject<{
+        mutationRef: z.ZodNonOptional<z.ZodTemplateLiteral<`Mutation/${number}`>>;
+        timestamp: z.ZodNonOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    updated: z.ZodNonOptional<z.ZodObject<{
+        mutationRef: z.ZodNonOptional<z.ZodTemplateLiteral<`Mutation/${number}`>>;
+        timestamp: z.ZodNonOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    data: z.ZodNonOptional<z.ZodObject<{
+        content: z.ZodString;
+    }, z.core.$strip>>;
+    children: z.ZodNonOptional<z.ZodObject<{}, z.core.$strip>>;
+    parents: z.ZodNonOptional<z.ZodObject<{
+        post: z.ZodTemplateLiteral<`Post/${number}`>;
+    }, z.core.$strip>>;
+    ancestors: z.ZodNonOptional<z.ZodObject<{}, z.core.$strip>>;
+}, z.core.$strict>;

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

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const CreatePostMutationSchema: z.ZodObject<{
+    ref: z.ZodTemplateLiteral<`Mutation/${number}`>;
+    timestamp: z.ZodString;
+    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>;
+    }, z.core.$strip>;
+    changeSetRef: z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]> | z.ZodTemplateLiteral<never> | z.ZodNullable<z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]>> | z.ZodNullable<z.ZodTemplateLiteral<never>>;
+    payload: z.ZodObject<{
+        title: z.ZodString;
+        slug: z.ZodOptional<z.ZodString>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    log: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strict>;

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

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const CreateUserMutationSchema: z.ZodObject<{
+    ref: z.ZodTemplateLiteral<`Mutation/${number}`>;
+    timestamp: z.ZodString;
+    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>;
+    }, z.core.$strip>;
+    changeSetRef: z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]> | z.ZodTemplateLiteral<never> | z.ZodNullable<z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]>> | z.ZodNullable<z.ZodTemplateLiteral<never>>;
+    payload: z.ZodObject<{
+        email: z.ZodString;
+    }, z.core.$strip>;
+    log: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strict>;

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

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

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

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const DraftSchema: z.ZodObject<{
+    ref: z.ZodNonOptional<z.ZodTemplateLiteral<`Draft/${number}`>>;
+    entity: z.ZodNonOptional<z.ZodLiteral<"Draft">>;
+    created: z.ZodNonOptional<z.ZodObject<{
+        mutationRef: z.ZodNonOptional<z.ZodTemplateLiteral<`Mutation/${number}`>>;
+        timestamp: z.ZodNonOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    updated: z.ZodNonOptional<z.ZodObject<{
+        mutationRef: z.ZodNonOptional<z.ZodTemplateLiteral<`Mutation/${number}`>>;
+        timestamp: z.ZodNonOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    data: z.ZodNonOptional<z.ZodObject<{}, z.core.$strip>>;
+    children: z.ZodNonOptional<z.ZodObject<{}, z.core.$strip>>;
+    parents: z.ZodNonOptional<z.ZodObject<{
+        post: z.ZodTemplateLiteral<`Post/${number}`>;
+    }, z.core.$strip>>;
+    ancestors: z.ZodNonOptional<z.ZodObject<{}, z.core.$strip>>;
+}, z.core.$strict>;

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

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

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const PostSchema: z.ZodObject<{
+    ref: z.ZodNonOptional<z.ZodTemplateLiteral<`Post/${number}`>>;
+    entity: z.ZodNonOptional<z.ZodLiteral<"Post">>;
+    created: z.ZodNonOptional<z.ZodObject<{
+        mutationRef: z.ZodNonOptional<z.ZodTemplateLiteral<`Mutation/${number}`>>;
+        timestamp: z.ZodNonOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    updated: z.ZodNonOptional<z.ZodObject<{
+        mutationRef: z.ZodNonOptional<z.ZodTemplateLiteral<`Mutation/${number}`>>;
+        timestamp: z.ZodNonOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    data: z.ZodNonOptional<z.ZodObject<{
+        title: z.ZodString;
+        text: z.ZodOptional<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+        slug: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    children: z.ZodNonOptional<z.ZodObject<{
+        blocks: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    parents: z.ZodNonOptional<z.ZodObject<{
+        author: z.ZodOptional<z.ZodTemplateLiteral<`User/${number}`>>;
+    }, z.core.$strip>>;
+    ancestors: z.ZodNonOptional<z.ZodObject<{}, z.core.$strip>>;
+}, z.core.$strict>;
+export type Post = z.infer<typeof PostSchema>;

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

@@ -0,0 +1 @@
+export declare const PostVersionRefSchema: import("zod").ZodTemplateLiteral<`PostVersion/${number}`>;

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const UpdatePostMutationSchema: z.ZodObject<{
+    ref: z.ZodTemplateLiteral<`Mutation/${number}`>;
+    timestamp: z.ZodString;
+    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>;
+    }, z.core.$strip>;
+    changeSetRef: z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]> | z.ZodTemplateLiteral<never> | z.ZodNullable<z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]>> | z.ZodNullable<z.ZodTemplateLiteral<never>>;
+    payload: z.ZodObject<{
+        ref: z.ZodTemplateLiteral<`Post/${number}`>;
+        title: z.ZodOptional<z.ZodString>;
+        tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        authorRef: z.ZodOptional<z.ZodTemplateLiteral<`User/${number}`>>;
+    }, z.core.$strip>;
+    log: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strict>;

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

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const UpdatePostTitleMutationSchema: z.ZodObject<{
+    ref: z.ZodTemplateLiteral<`Mutation/${number}`>;
+    timestamp: z.ZodString;
+    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>;
+    }, z.core.$strip>;
+    changeSetRef: z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]> | z.ZodTemplateLiteral<never> | z.ZodNullable<z.ZodUnion<readonly [z.ZodTemplateLiteral<`${string}/${number}`>, z.ZodString]>> | z.ZodNullable<z.ZodTemplateLiteral<never>>;
+    payload: z.ZodObject<{
+        ref: z.ZodTemplateLiteral<`Post/${number}`>;
+        title: z.ZodString;
+    }, z.core.$strip>;
+    log: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strict>;