@memoryengine/client 0.1.0

package/dist/schemas/rpc.d.ts

@@ -0,0 +1,1312 @@
+/**
+ * RPC Contract - maps method names to input/output types
+ *
+ * This is the key to type inference: define the contract once,
+ * and both server validation and client types are derived from it.
+ */
+import { z } from "zod";
+export declare const authMethods: {
+    readonly "auth.login": {
+        input: z.ZodObject<{
+            identifier: z.ZodString;
+            password: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                identifier: string;
+                password: string;
+            };
+            output: {
+                key: string;
+                principal: {
+                    id: string;
+                    email: string | null;
+                    name: string;
+                    superuser: boolean;
+                    createrole: boolean;
+                    can_login: boolean;
+                };
+            };
+        };
+    };
+    readonly "auth.whoami": {
+        input: z.ZodObject<{}, z.core.$strip>;
+        _types: {
+            input: Record<string, never>;
+            output: {
+                principalId: string;
+                name: string;
+                email: string | null;
+                superuser: boolean;
+                createrole: boolean;
+                can_login: boolean;
+            };
+        };
+    };
+    readonly "auth.createApiKey": {
+        input: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                name: string;
+            };
+            output: {
+                key: string;
+                id: string;
+            };
+        };
+    };
+    readonly "auth.listApiKeys": {
+        input: z.ZodObject<{}, z.core.$strip>;
+        _types: {
+            input: Record<string, never>;
+            output: {
+                id: string;
+                name: string;
+                expires_at: string;
+                created_at: string;
+            }[];
+        };
+    };
+    readonly "auth.revokeApiKey": {
+        input: z.ZodObject<{
+            keyId: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                keyId: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+};
+export declare const principalMethods: {
+    readonly "principal.list": {
+        input: z.ZodObject<{}, z.core.$strip>;
+        _types: {
+            input: Record<string, never>;
+            output: {
+                id: string;
+                email: string | null;
+                name: string;
+                superuser: boolean;
+                createrole: boolean;
+                can_login: boolean;
+                created_at: string;
+            }[];
+        };
+    };
+    readonly "principal.get": {
+        input: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                name: string;
+            };
+            output: {
+                id: string;
+                email: string | null;
+                name: string;
+                superuser: boolean;
+                createrole: boolean;
+                can_login: boolean;
+                created_at: string;
+            };
+        };
+    };
+    readonly "principal.create": {
+        input: z.ZodObject<{
+            name: z.ZodString;
+            email: z.ZodOptional<z.ZodEmail>;
+            password: z.ZodOptional<z.ZodString>;
+            superuser: z.ZodOptional<z.ZodBoolean>;
+            createrole: z.ZodOptional<z.ZodBoolean>;
+            can_login: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                name: string;
+                email?: string | undefined;
+                password?: string | undefined;
+                superuser?: boolean | undefined;
+                createrole?: boolean | undefined;
+                can_login?: boolean | undefined;
+            };
+            output: {
+                id: string;
+                email: string | null;
+                name: string;
+                superuser: boolean;
+                createrole: boolean;
+                can_login: boolean;
+            };
+        };
+    };
+    readonly "principal.delete": {
+        input: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                name: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "principal.setPassword": {
+        input: z.ZodObject<{
+            name: z.ZodString;
+            password: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                name: string;
+                password: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+};
+export declare const grantMethods: {
+    readonly "grant.create": {
+        input: z.ZodObject<{
+            principal_name: z.ZodString;
+            tree_path: z.ZodString;
+            actions: z.ZodArray<z.ZodEnum<{
+                read: "read";
+                create: "create";
+                update: "update";
+                delete: "delete";
+            }>>;
+            with_grant_option: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                principal_name: string;
+                tree_path: string;
+                actions: ("read" | "create" | "update" | "delete")[];
+                with_grant_option?: boolean | undefined;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "grant.revoke": {
+        input: z.ZodObject<{
+            principal_name: z.ZodString;
+            tree_path: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                principal_name: string;
+                tree_path: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "grant.list": {
+        input: z.ZodObject<{
+            principal_name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                principal_name?: string | undefined;
+            };
+            output: {
+                id: string;
+                principal_id: string;
+                tree_path: string;
+                actions: string[];
+                with_grant_option: boolean;
+                granted_by: string | null;
+                created_at: string;
+            }[];
+        };
+    };
+    readonly "grant.check": {
+        input: z.ZodObject<{
+            tree_path: z.ZodString;
+            action: z.ZodEnum<{
+                read: "read";
+                create: "create";
+                update: "update";
+                delete: "delete";
+            }>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                tree_path: string;
+                action: "read" | "create" | "update" | "delete";
+            };
+            output: {
+                allowed: boolean;
+            };
+        };
+    };
+};
+export declare const ownerMethods: {
+    readonly "owner.set": {
+        input: z.ZodObject<{
+            tree_path: z.ZodString;
+            principal_name: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                tree_path: string;
+                principal_name: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "owner.remove": {
+        input: z.ZodObject<{
+            tree_path: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                tree_path: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "owner.get": {
+        input: z.ZodObject<{
+            tree_path: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                tree_path: string;
+            };
+            output: {
+                tree_path: string;
+                principal_id: string;
+                principal_name: string;
+                created_by: string | null;
+                created_at: string;
+            } | null;
+        };
+    };
+    readonly "owner.list": {
+        input: z.ZodObject<{
+            principal_name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                principal_name?: string | undefined;
+            };
+            output: {
+                tree_path: string;
+                principal_id: string;
+                principal_name: string;
+                created_by: string | null;
+                created_at: string;
+            }[];
+        };
+    };
+};
+export declare const roleMethods: {
+    readonly "role.addMember": {
+        input: z.ZodObject<{
+            role_name: z.ZodString;
+            member_name: z.ZodString;
+            with_admin_option: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                role_name: string;
+                member_name: string;
+                with_admin_option?: boolean | undefined;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "role.removeMember": {
+        input: z.ZodObject<{
+            role_name: z.ZodString;
+            member_name: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                role_name: string;
+                member_name: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "role.listMembers": {
+        input: z.ZodObject<{
+            role_name: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                role_name: string;
+            };
+            output: {
+                id: string;
+                name: string;
+                email: string | null;
+                superuser: boolean;
+                can_login: boolean;
+                with_admin_option: boolean;
+                created_at: string;
+            }[];
+        };
+    };
+    readonly "role.listForPrincipal": {
+        input: z.ZodObject<{
+            principal_name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                principal_name?: string | undefined;
+            };
+            output: {
+                id: string;
+                name: string;
+                created_at: string;
+            }[];
+        };
+    };
+};
+export declare const engramMethods: {
+    readonly "engram.create": {
+        input: z.ZodObject<{
+            id: z.ZodOptional<z.ZodUUID>;
+            content: z.ZodString;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            tree: z.ZodOptional<z.ZodString>;
+            temporal: z.ZodOptional<z.ZodObject<{
+                start: z.ZodString;
+                end: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                content: string;
+                id?: string | undefined;
+                meta?: Record<string, unknown> | undefined;
+                tree?: string | undefined;
+                temporal?: {
+                    start: string;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            output: {
+                id: string;
+                content: string;
+                meta: Record<string, unknown>;
+                tree: string;
+                temporal: string | null;
+                created_at: string;
+                updated_at: string | null;
+                has_embedding?: boolean | undefined;
+            };
+        };
+    };
+    readonly "engram.batchCreate": {
+        input: z.ZodObject<{
+            engrams: z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodUUID>;
+                content: z.ZodString;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                tree: z.ZodOptional<z.ZodString>;
+                temporal: z.ZodOptional<z.ZodObject<{
+                    start: z.ZodString;
+                    end: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                engrams: {
+                    content: string;
+                    id?: string | undefined;
+                    meta?: Record<string, unknown> | undefined;
+                    tree?: string | undefined;
+                    temporal?: {
+                        start: string;
+                        end?: string | undefined;
+                    } | undefined;
+                }[];
+            };
+            output: {
+                ids: string[];
+            };
+        };
+    };
+    readonly "engram.get": {
+        input: z.ZodObject<{
+            id: z.ZodUUID;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                id: string;
+            };
+            output: {
+                id: string;
+                content: string;
+                meta: Record<string, unknown>;
+                tree: string;
+                temporal: string | null;
+                created_at: string;
+                updated_at: string | null;
+                has_embedding?: boolean | undefined;
+            };
+        };
+    };
+    readonly "engram.update": {
+        input: z.ZodObject<{
+            id: z.ZodUUID;
+            content: z.ZodOptional<z.ZodString>;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            tree: z.ZodOptional<z.ZodString>;
+            temporal: z.ZodOptional<z.ZodObject<{
+                start: z.ZodString;
+                end: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                id: string;
+                content?: string | undefined;
+                meta?: Record<string, unknown> | undefined;
+                tree?: string | undefined;
+                temporal?: {
+                    start: string;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            output: {
+                id: string;
+                content: string;
+                meta: Record<string, unknown>;
+                tree: string;
+                temporal: string | null;
+                created_at: string;
+                updated_at: string | null;
+                has_embedding?: boolean | undefined;
+            };
+        };
+    };
+    readonly "engram.delete": {
+        input: z.ZodObject<{
+            id: z.ZodUUID;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                id: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "engram.search": {
+        input: z.ZodObject<{
+            semantic: z.ZodOptional<z.ZodString>;
+            fulltext: z.ZodOptional<z.ZodString>;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            tree: z.ZodOptional<z.ZodString>;
+            temporal: z.ZodOptional<z.ZodObject<{
+                contains: z.ZodOptional<z.ZodString>;
+                overlaps: z.ZodOptional<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+                within: z.ZodOptional<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+            }, z.core.$strip>>;
+            limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            candidateLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            hybrid: z.ZodOptional<z.ZodObject<{
+                weights: z.ZodOptional<z.ZodObject<{
+                    fulltext: z.ZodOptional<z.ZodNumber>;
+                    semantic: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                semantic?: string | undefined;
+                fulltext?: string | undefined;
+                meta?: Record<string, unknown> | undefined;
+                tree?: string | undefined;
+                temporal?: {
+                    contains?: string | undefined;
+                    overlaps?: [string, string] | undefined;
+                    within?: [string, string] | undefined;
+                } | undefined;
+                limit?: number | undefined;
+                candidateLimit?: number | undefined;
+                hybrid?: {
+                    weights?: {
+                        fulltext?: number | undefined;
+                        semantic?: number | undefined;
+                    } | undefined;
+                } | undefined;
+            };
+            output: {
+                results: {
+                    id: string;
+                    content: string;
+                    meta: Record<string, unknown>;
+                    tree: string;
+                    temporal: string | null;
+                    created_at: string;
+                    updated_at: string | null;
+                    score: number;
+                    has_embedding?: boolean | undefined;
+                }[];
+                total: number;
+                limit: number;
+            };
+        };
+    };
+    readonly "engram.mv": {
+        input: z.ZodObject<{
+            source: z.ZodString;
+            destination: z.ZodString;
+            dry_run: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                source: string;
+                destination: string;
+                dry_run?: boolean | undefined;
+            };
+            output: {
+                moved: number;
+                source: string;
+                destination: string;
+            };
+        };
+    };
+};
+/** All registered RPC methods */
+export declare const rpcMethods: {
+    readonly "engram.create": {
+        input: z.ZodObject<{
+            id: z.ZodOptional<z.ZodUUID>;
+            content: z.ZodString;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            tree: z.ZodOptional<z.ZodString>;
+            temporal: z.ZodOptional<z.ZodObject<{
+                start: z.ZodString;
+                end: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                content: string;
+                id?: string | undefined;
+                meta?: Record<string, unknown> | undefined;
+                tree?: string | undefined;
+                temporal?: {
+                    start: string;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            output: {
+                id: string;
+                content: string;
+                meta: Record<string, unknown>;
+                tree: string;
+                temporal: string | null;
+                created_at: string;
+                updated_at: string | null;
+                has_embedding?: boolean | undefined;
+            };
+        };
+    };
+    readonly "engram.batchCreate": {
+        input: z.ZodObject<{
+            engrams: z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodUUID>;
+                content: z.ZodString;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                tree: z.ZodOptional<z.ZodString>;
+                temporal: z.ZodOptional<z.ZodObject<{
+                    start: z.ZodString;
+                    end: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                engrams: {
+                    content: string;
+                    id?: string | undefined;
+                    meta?: Record<string, unknown> | undefined;
+                    tree?: string | undefined;
+                    temporal?: {
+                        start: string;
+                        end?: string | undefined;
+                    } | undefined;
+                }[];
+            };
+            output: {
+                ids: string[];
+            };
+        };
+    };
+    readonly "engram.get": {
+        input: z.ZodObject<{
+            id: z.ZodUUID;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                id: string;
+            };
+            output: {
+                id: string;
+                content: string;
+                meta: Record<string, unknown>;
+                tree: string;
+                temporal: string | null;
+                created_at: string;
+                updated_at: string | null;
+                has_embedding?: boolean | undefined;
+            };
+        };
+    };
+    readonly "engram.update": {
+        input: z.ZodObject<{
+            id: z.ZodUUID;
+            content: z.ZodOptional<z.ZodString>;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            tree: z.ZodOptional<z.ZodString>;
+            temporal: z.ZodOptional<z.ZodObject<{
+                start: z.ZodString;
+                end: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                id: string;
+                content?: string | undefined;
+                meta?: Record<string, unknown> | undefined;
+                tree?: string | undefined;
+                temporal?: {
+                    start: string;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            output: {
+                id: string;
+                content: string;
+                meta: Record<string, unknown>;
+                tree: string;
+                temporal: string | null;
+                created_at: string;
+                updated_at: string | null;
+                has_embedding?: boolean | undefined;
+            };
+        };
+    };
+    readonly "engram.delete": {
+        input: z.ZodObject<{
+            id: z.ZodUUID;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                id: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "engram.search": {
+        input: z.ZodObject<{
+            semantic: z.ZodOptional<z.ZodString>;
+            fulltext: z.ZodOptional<z.ZodString>;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            tree: z.ZodOptional<z.ZodString>;
+            temporal: z.ZodOptional<z.ZodObject<{
+                contains: z.ZodOptional<z.ZodString>;
+                overlaps: z.ZodOptional<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+                within: z.ZodOptional<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+            }, z.core.$strip>>;
+            limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            candidateLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            hybrid: z.ZodOptional<z.ZodObject<{
+                weights: z.ZodOptional<z.ZodObject<{
+                    fulltext: z.ZodOptional<z.ZodNumber>;
+                    semantic: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                semantic?: string | undefined;
+                fulltext?: string | undefined;
+                meta?: Record<string, unknown> | undefined;
+                tree?: string | undefined;
+                temporal?: {
+                    contains?: string | undefined;
+                    overlaps?: [string, string] | undefined;
+                    within?: [string, string] | undefined;
+                } | undefined;
+                limit?: number | undefined;
+                candidateLimit?: number | undefined;
+                hybrid?: {
+                    weights?: {
+                        fulltext?: number | undefined;
+                        semantic?: number | undefined;
+                    } | undefined;
+                } | undefined;
+            };
+            output: {
+                results: {
+                    id: string;
+                    content: string;
+                    meta: Record<string, unknown>;
+                    tree: string;
+                    temporal: string | null;
+                    created_at: string;
+                    updated_at: string | null;
+                    score: number;
+                    has_embedding?: boolean | undefined;
+                }[];
+                total: number;
+                limit: number;
+            };
+        };
+    };
+    readonly "engram.mv": {
+        input: z.ZodObject<{
+            source: z.ZodString;
+            destination: z.ZodString;
+            dry_run: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                source: string;
+                destination: string;
+                dry_run?: boolean | undefined;
+            };
+            output: {
+                moved: number;
+                source: string;
+                destination: string;
+            };
+        };
+    };
+    readonly "role.addMember": {
+        input: z.ZodObject<{
+            role_name: z.ZodString;
+            member_name: z.ZodString;
+            with_admin_option: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                role_name: string;
+                member_name: string;
+                with_admin_option?: boolean | undefined;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "role.removeMember": {
+        input: z.ZodObject<{
+            role_name: z.ZodString;
+            member_name: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                role_name: string;
+                member_name: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "role.listMembers": {
+        input: z.ZodObject<{
+            role_name: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                role_name: string;
+            };
+            output: {
+                id: string;
+                name: string;
+                email: string | null;
+                superuser: boolean;
+                can_login: boolean;
+                with_admin_option: boolean;
+                created_at: string;
+            }[];
+        };
+    };
+    readonly "role.listForPrincipal": {
+        input: z.ZodObject<{
+            principal_name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                principal_name?: string | undefined;
+            };
+            output: {
+                id: string;
+                name: string;
+                created_at: string;
+            }[];
+        };
+    };
+    readonly "owner.set": {
+        input: z.ZodObject<{
+            tree_path: z.ZodString;
+            principal_name: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                tree_path: string;
+                principal_name: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "owner.remove": {
+        input: z.ZodObject<{
+            tree_path: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                tree_path: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "owner.get": {
+        input: z.ZodObject<{
+            tree_path: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                tree_path: string;
+            };
+            output: {
+                tree_path: string;
+                principal_id: string;
+                principal_name: string;
+                created_by: string | null;
+                created_at: string;
+            } | null;
+        };
+    };
+    readonly "owner.list": {
+        input: z.ZodObject<{
+            principal_name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                principal_name?: string | undefined;
+            };
+            output: {
+                tree_path: string;
+                principal_id: string;
+                principal_name: string;
+                created_by: string | null;
+                created_at: string;
+            }[];
+        };
+    };
+    readonly "grant.create": {
+        input: z.ZodObject<{
+            principal_name: z.ZodString;
+            tree_path: z.ZodString;
+            actions: z.ZodArray<z.ZodEnum<{
+                read: "read";
+                create: "create";
+                update: "update";
+                delete: "delete";
+            }>>;
+            with_grant_option: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                principal_name: string;
+                tree_path: string;
+                actions: ("read" | "create" | "update" | "delete")[];
+                with_grant_option?: boolean | undefined;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "grant.revoke": {
+        input: z.ZodObject<{
+            principal_name: z.ZodString;
+            tree_path: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                principal_name: string;
+                tree_path: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "grant.list": {
+        input: z.ZodObject<{
+            principal_name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                principal_name?: string | undefined;
+            };
+            output: {
+                id: string;
+                principal_id: string;
+                tree_path: string;
+                actions: string[];
+                with_grant_option: boolean;
+                granted_by: string | null;
+                created_at: string;
+            }[];
+        };
+    };
+    readonly "grant.check": {
+        input: z.ZodObject<{
+            tree_path: z.ZodString;
+            action: z.ZodEnum<{
+                read: "read";
+                create: "create";
+                update: "update";
+                delete: "delete";
+            }>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                tree_path: string;
+                action: "read" | "create" | "update" | "delete";
+            };
+            output: {
+                allowed: boolean;
+            };
+        };
+    };
+    readonly "principal.list": {
+        input: z.ZodObject<{}, z.core.$strip>;
+        _types: {
+            input: Record<string, never>;
+            output: {
+                id: string;
+                email: string | null;
+                name: string;
+                superuser: boolean;
+                createrole: boolean;
+                can_login: boolean;
+                created_at: string;
+            }[];
+        };
+    };
+    readonly "principal.get": {
+        input: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                name: string;
+            };
+            output: {
+                id: string;
+                email: string | null;
+                name: string;
+                superuser: boolean;
+                createrole: boolean;
+                can_login: boolean;
+                created_at: string;
+            };
+        };
+    };
+    readonly "principal.create": {
+        input: z.ZodObject<{
+            name: z.ZodString;
+            email: z.ZodOptional<z.ZodEmail>;
+            password: z.ZodOptional<z.ZodString>;
+            superuser: z.ZodOptional<z.ZodBoolean>;
+            createrole: z.ZodOptional<z.ZodBoolean>;
+            can_login: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                name: string;
+                email?: string | undefined;
+                password?: string | undefined;
+                superuser?: boolean | undefined;
+                createrole?: boolean | undefined;
+                can_login?: boolean | undefined;
+            };
+            output: {
+                id: string;
+                email: string | null;
+                name: string;
+                superuser: boolean;
+                createrole: boolean;
+                can_login: boolean;
+            };
+        };
+    };
+    readonly "principal.delete": {
+        input: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                name: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "principal.setPassword": {
+        input: z.ZodObject<{
+            name: z.ZodString;
+            password: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                name: string;
+                password: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+    readonly "auth.login": {
+        input: z.ZodObject<{
+            identifier: z.ZodString;
+            password: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                identifier: string;
+                password: string;
+            };
+            output: {
+                key: string;
+                principal: {
+                    id: string;
+                    email: string | null;
+                    name: string;
+                    superuser: boolean;
+                    createrole: boolean;
+                    can_login: boolean;
+                };
+            };
+        };
+    };
+    readonly "auth.whoami": {
+        input: z.ZodObject<{}, z.core.$strip>;
+        _types: {
+            input: Record<string, never>;
+            output: {
+                principalId: string;
+                name: string;
+                email: string | null;
+                superuser: boolean;
+                createrole: boolean;
+                can_login: boolean;
+            };
+        };
+    };
+    readonly "auth.createApiKey": {
+        input: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                name: string;
+            };
+            output: {
+                key: string;
+                id: string;
+            };
+        };
+    };
+    readonly "auth.listApiKeys": {
+        input: z.ZodObject<{}, z.core.$strip>;
+        _types: {
+            input: Record<string, never>;
+            output: {
+                id: string;
+                name: string;
+                expires_at: string;
+                created_at: string;
+            }[];
+        };
+    };
+    readonly "auth.revokeApiKey": {
+        input: z.ZodObject<{
+            keyId: z.ZodString;
+        }, z.core.$strip>;
+        _types: {
+            input: {
+                keyId: string;
+            };
+            output: {
+                success: true;
+            };
+        };
+    };
+};
+/** Union of all method names */
+export type RpcMethodName = keyof typeof rpcMethods;
+/** Extract input type for a method */
+export type RpcInput<M extends RpcMethodName> = (typeof rpcMethods)[M]["_types"]["input"];
+/** Extract output type for a method */
+export type RpcOutput<M extends RpcMethodName> = (typeof rpcMethods)[M]["_types"]["output"];
+/** Get the input schema for runtime validation */
+export declare function getInputSchema<M extends RpcMethodName>(method: M): z.ZodObject<{
+    identifier: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip> | z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip> | z.ZodObject<{
+    keyId: z.ZodString;
+}, z.core.$strip> | z.ZodObject<{
+    id: z.ZodOptional<z.ZodUUID>;
+    content: z.ZodString;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tree: z.ZodOptional<z.ZodString>;
+    temporal: z.ZodOptional<z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip> | z.ZodObject<{
+    engrams: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodUUID>;
+        content: z.ZodString;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        tree: z.ZodOptional<z.ZodString>;
+        temporal: z.ZodOptional<z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip> | z.ZodObject<{
+    id: z.ZodUUID;
+    content: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tree: z.ZodOptional<z.ZodString>;
+    temporal: z.ZodOptional<z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip> | z.ZodObject<{
+    id: z.ZodUUID;
+}, z.core.$strip> | z.ZodObject<{
+    id: z.ZodUUID;
+}, z.core.$strip> | z.ZodObject<{
+    source: z.ZodString;
+    destination: z.ZodString;
+    dry_run: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip> | z.ZodObject<{
+    semantic: z.ZodOptional<z.ZodString>;
+    fulltext: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tree: z.ZodOptional<z.ZodString>;
+    temporal: z.ZodOptional<z.ZodObject<{
+        contains: z.ZodOptional<z.ZodString>;
+        overlaps: z.ZodOptional<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+        within: z.ZodOptional<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+    }, z.core.$strip>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    candidateLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    hybrid: z.ZodOptional<z.ZodObject<{
+        weights: z.ZodOptional<z.ZodObject<{
+            fulltext: z.ZodOptional<z.ZodNumber>;
+            semantic: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip> | z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip> | z.ZodObject<{
+    name: z.ZodString;
+    email: z.ZodOptional<z.ZodEmail>;
+    password: z.ZodOptional<z.ZodString>;
+    superuser: z.ZodOptional<z.ZodBoolean>;
+    createrole: z.ZodOptional<z.ZodBoolean>;
+    can_login: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip> | z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip> | z.ZodObject<{
+    name: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip> | z.ZodObject<{
+    principal_name: z.ZodString;
+    tree_path: z.ZodString;
+    actions: z.ZodArray<z.ZodEnum<{
+        read: "read";
+        create: "create";
+        update: "update";
+        delete: "delete";
+    }>>;
+    with_grant_option: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip> | z.ZodObject<{
+    principal_name: z.ZodString;
+    tree_path: z.ZodString;
+}, z.core.$strip> | z.ZodObject<{
+    principal_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip> | z.ZodObject<{
+    tree_path: z.ZodString;
+    action: z.ZodEnum<{
+        read: "read";
+        create: "create";
+        update: "update";
+        delete: "delete";
+    }>;
+}, z.core.$strip> | z.ZodObject<{
+    role_name: z.ZodString;
+    member_name: z.ZodString;
+    with_admin_option: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip> | z.ZodObject<{
+    role_name: z.ZodString;
+    member_name: z.ZodString;
+}, z.core.$strip> | z.ZodObject<{
+    role_name: z.ZodString;
+}, z.core.$strip> | z.ZodObject<{
+    principal_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip> | z.ZodObject<{
+    tree_path: z.ZodString;
+    principal_name: z.ZodString;
+}, z.core.$strip> | z.ZodObject<{
+    tree_path: z.ZodString;
+}, z.core.$strip> | z.ZodObject<{
+    tree_path: z.ZodString;
+}, z.core.$strip> | z.ZodObject<{
+    principal_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip> | z.ZodObject<{}, z.core.$strip>;
+/** Get the output schema for runtime response validation */
+export declare function getOutputSchema(method: string): z.ZodType | undefined;
+//# sourceMappingURL=rpc.d.ts.map