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

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

@@ -0,0 +1,15 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const BlockImageEntity: Entity<"BlockImage", z.ZodObject<{
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>, z.ZodObject<{
+    parent: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+}, "strip", z.ZodTypeAny, {
+    parent: `Post/${string}`;
+}, {
+    parent: `Post/${string}`;
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>>;

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

@@ -0,0 +1,15 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const BlockParagraph: Entity<"BlockParagraph", z.ZodObject<{
+    content: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    content?: string | undefined;
+}, {
+    content?: string | undefined;
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>, z.ZodObject<{
+    parent: z.ZodUnion<[z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>, z.ZodUnion<[z.ZodType<`BlockParagraph/${string}`, z.ZodTypeDef, `BlockParagraph/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>]>;
+}, "strip", z.ZodTypeAny, {
+    parent: `Post/${string}` | `BlockParagraph/${string}` | `BlockRow/${string}`;
+}, {
+    parent: `Post/${string}` | `BlockParagraph/${string}` | `BlockRow/${string}`;
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>>;

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

@@ -0,0 +1,15 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const BlockRow: Entity<"BlockRow", z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>, 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}`)[];
+}>, z.ZodObject<{
+    parent: z.ZodUnion<[z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>, z.ZodUnion<[z.ZodType<`BlockParagraph/${string}`, z.ZodTypeDef, `BlockParagraph/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>]>;
+}, "strip", z.ZodTypeAny, {
+    parent: `Post/${string}` | `BlockParagraph/${string}` | `BlockRow/${string}`;
+}, {
+    parent: `Post/${string}` | `BlockParagraph/${string}` | `BlockRow/${string}`;
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>>;

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

@@ -0,0 +1,15 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const Draft: Entity<"Draft", z.ZodObject<{
+    appliedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    appliedAt?: string | undefined;
+}, {
+    appliedAt?: string | undefined;
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>, z.ZodObject<{
+    post: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+}, "strip", z.ZodTypeAny, {
+    post: `Post/${string}`;
+}, {
+    post: `Post/${string}`;
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>>;

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

@@ -0,0 +1,30 @@
+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, "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;
+}>, z.ZodObject<{
+    blocks: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    blocks: string[];
+}, {
+    blocks: string[];
+}>, z.ZodObject<{
+    author: z.ZodOptional<z.ZodType<`User/${string}`, z.ZodTypeDef, `User/${string}`>>;
+}, "strip", z.ZodTypeAny, {
+    author?: `User/${string}` | undefined;
+}, {
+    author?: `User/${string}` | undefined;
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>>;

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

@@ -0,0 +1,18 @@
+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, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    snapshot: any[];
+}, {
+    version: number;
+    snapshot: any[];
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>, z.ZodObject<{
+    post: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+}, "strip", z.ZodTypeAny, {
+    post: `Post/${string}`;
+}, {
+    post: `Post/${string}`;
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>>;

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

@@ -0,0 +1,9 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const UserEntity: Entity<"User", z.ZodObject<{
+    email: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+}, {
+    email: string;
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>>;

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

@@ -0,0 +1,97 @@
+export declare const entities: (import("roc-db").Entity<"Draft", import("zod").ZodObject<{
+    appliedAt: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    appliedAt?: string | undefined;
+}, {
+    appliedAt?: string | undefined;
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{
+    post: import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>;
+}, "strip", import("zod").ZodTypeAny, {
+    post: `Post/${string}`;
+}, {
+    post: `Post/${string}`;
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>> | import("roc-db").Entity<"BlockImage", import("zod").ZodObject<{
+    url: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{
+    parent: import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>;
+}, "strip", import("zod").ZodTypeAny, {
+    parent: `Post/${string}`;
+}, {
+    parent: `Post/${string}`;
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>> | 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, "many">;
+    slug: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    title: string;
+    tags: string[];
+    text?: string | undefined;
+    slug?: string | undefined;
+}, {
+    title: string;
+    tags: string[];
+    text?: string | undefined;
+    slug?: string | undefined;
+}>, import("zod").ZodObject<{
+    blocks: import("zod").ZodArray<import("zod").ZodString, "many">;
+}, "strip", import("zod").ZodTypeAny, {
+    blocks: string[];
+}, {
+    blocks: string[];
+}>, import("zod").ZodObject<{
+    author: import("zod").ZodOptional<import("zod").ZodType<`User/${string}`, import("zod").ZodTypeDef, `User/${string}`>>;
+}, "strip", import("zod").ZodTypeAny, {
+    author?: `User/${string}` | undefined;
+}, {
+    author?: `User/${string}` | undefined;
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>> | import("roc-db").Entity<"BlockParagraph", import("zod").ZodObject<{
+    content: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    content?: string | undefined;
+}, {
+    content?: string | undefined;
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{
+    parent: import("zod").ZodUnion<[import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>, import("zod").ZodUnion<[import("zod").ZodType<`BlockParagraph/${string}`, import("zod").ZodTypeDef, `BlockParagraph/${string}`>, import("zod").ZodType<`BlockRow/${string}`, import("zod").ZodTypeDef, `BlockRow/${string}`>]>]>;
+}, "strip", import("zod").ZodTypeAny, {
+    parent: `Post/${string}` | `BlockParagraph/${string}` | `BlockRow/${string}`;
+}, {
+    parent: `Post/${string}` | `BlockParagraph/${string}` | `BlockRow/${string}`;
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>> | import("roc-db").Entity<"BlockRow", import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{
+    blocks: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodType<`BlockParagraph/${string}`, import("zod").ZodTypeDef, `BlockParagraph/${string}`>, import("zod").ZodType<`BlockRow/${string}`, import("zod").ZodTypeDef, `BlockRow/${string}`>]>, "many">;
+}, "strip", import("zod").ZodTypeAny, {
+    blocks: (`BlockParagraph/${string}` | `BlockRow/${string}`)[];
+}, {
+    blocks: (`BlockParagraph/${string}` | `BlockRow/${string}`)[];
+}>, import("zod").ZodObject<{
+    parent: import("zod").ZodUnion<[import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>, import("zod").ZodUnion<[import("zod").ZodType<`BlockParagraph/${string}`, import("zod").ZodTypeDef, `BlockParagraph/${string}`>, import("zod").ZodType<`BlockRow/${string}`, import("zod").ZodTypeDef, `BlockRow/${string}`>]>]>;
+}, "strip", import("zod").ZodTypeAny, {
+    parent: `Post/${string}` | `BlockParagraph/${string}` | `BlockRow/${string}`;
+}, {
+    parent: `Post/${string}` | `BlockParagraph/${string}` | `BlockRow/${string}`;
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>> | import("roc-db").Entity<"PostVersion", import("zod").ZodObject<{
+    version: import("zod").ZodNumber;
+    snapshot: import("zod").ZodArray<import("zod").ZodAny, "many">;
+}, "strip", import("zod").ZodTypeAny, {
+    version: number;
+    snapshot: any[];
+}, {
+    version: number;
+    snapshot: any[];
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{
+    post: import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>;
+}, "strip", import("zod").ZodTypeAny, {
+    post: `Post/${string}`;
+}, {
+    post: `Post/${string}`;
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>> | import("roc-db").Entity<"User", import("zod").ZodObject<{
+    email: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    email: string;
+}, {
+    email: string;
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>>)[];

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/${string}`, import("zod").ZodTypeDef, `Draft/${string}`>>;

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

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

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

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const createBlockParagrah: import("roc-db").WriteOperation<"createBlockParagraph", 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}`;
+}>>;

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

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const createBlockRow: import("roc-db").WriteOperation<"createBlockRow", 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}`;
+}>>;

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

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const createBlockTitle: import("roc-db").WriteOperation<"createBlockTitle", 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}`;
+}>>;

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

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const createDraft: import("roc-db").WriteOperation<"createDraft", z.ZodObject<{
+    postRef: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+}, "strict", z.ZodTypeAny, {
+    postRef: `Post/${string}`;
+}, {
+    postRef: `Post/${string}`;
+}>>;

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

@@ -0,0 +1,14 @@
+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, "many">>;
+}, "strict", z.ZodTypeAny, {
+    title: string;
+    tags: string[];
+    slug?: string | undefined;
+}, {
+    title: string;
+    tags?: string[] | undefined;
+    slug?: string | undefined;
+}>>;

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

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

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<[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">>;

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

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

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

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

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,11 @@
+import { z } from "zod";
+export declare const moveBlocks: import("roc-db").WriteOperation<"moveBlocks", 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;
+}>>;

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/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,14 @@
+import { z } from "zod";
+export declare const testTransactionalEdits: import("roc-db").WriteOperation<"testTransactionalEdits", 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;
+}>>;

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

@@ -0,0 +1,11 @@
+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;
+}>>;

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

@@ -0,0 +1,17 @@
+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;
+}, {
+    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

@@ -0,0 +1,11 @@
+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;
+}, {
+    ref: `Post/${string}`;
+    title: string;
+}>>;

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

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

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

@@ -0,0 +1,79 @@
+import { z } from "zod";
+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;
+    }, "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<{
+        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: {};
+}, {
+    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/BlockParagraphRefSchema.d.ts

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

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

@@ -0,0 +1,80 @@
+import { z } from "zod";
+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;
+    }, "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.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: {};
+}, {
+    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>;