@astrale-os/kernel-core 0.4.1

package/dist/schema/classes/View.class.d.ts

@@ -0,0 +1,3407 @@
+import { z } from 'zod';
+/**
+ * View — canonical implementation of UI.
+ *
+ * A View node carries its iframe URL through Function.binding.remoteUrl. The
+ * static methods are kernel syscalls so view resolution works without any
+ * distribution worker.
+ */
+export declare const View: import("@astrale-os/kernel-dsl").NodeClassDef<Omit<{
+    readonly implements: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+        readonly extends: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+            readonly extends: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly methods: {
+                    listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly filters: z.ZodOptional<z.ZodUnknown>;
+                    }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+                    push: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                        readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                };
+            }, "props"> & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly props: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+                readonly methods: {
+                    extendIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly with: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    constrainIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly by: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    excludeIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly without: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExtension: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeConstraint: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExclusion: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    grantPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    revokePerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    checkPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodBoolean, "sealed", boolean>;
+                    registerIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly signingKey: z.ZodOptional<z.ZodObject<{
+                            publicKey: z.ZodObject<{
+                                jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                                jwksUri: z.ZodOptional<z.ZodURL>;
+                            }, z.core.$strip>;
+                            credential: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.ZodObject<{
+                        iss: z.ZodString;
+                        sub: z.ZodString;
+                    }, z.core.$strip>, "sealed", boolean>;
+                    mintIdentityCredential: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodString, "sealed", boolean>;
+                    mintDelegationCredential: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly audience: z.ZodOptional<z.ZodString>;
+                        readonly delegation: z.ZodCustom<import("../..").UnresolvedIdentityExpr, import("../..").UnresolvedIdentityExpr>;
+                        readonly attestation: z.ZodOptional<z.ZodCustom<import("../..").SelfIdentityExpr, import("../..").SelfIdentityExpr>>;
+                        readonly ttl: z.ZodOptional<z.ZodNumber>;
+                    }, z.ZodString, "sealed", boolean>;
+                    findIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly issuer: z.ZodString;
+                        readonly subject: z.ZodString;
+                    }, z.ZodNullable<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", true>;
+                    whoami: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                };
+            }, "props"> & {
+                readonly properties: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+            } & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>];
+            readonly props: {
+                ref: z.ZodString;
+                inputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                outputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                code: z.ZodOptional<z.ZodObject<{
+                    authenticate: z.ZodOptional<z.ZodString>;
+                    authorize: z.ZodOptional<z.ZodString>;
+                    resolve: z.ZodOptional<z.ZodString>;
+                    invariants: z.ZodOptional<z.ZodString>;
+                    execute: z.ZodOptional<z.ZodString>;
+                    rollback: z.ZodOptional<z.ZodString>;
+                    effects: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                isStatic: z.ZodOptional<z.ZodBoolean>;
+                output: z.ZodOptional<z.ZodEnum<{
+                    binary: "binary";
+                    stream: "stream";
+                    value: "value";
+                }>>;
+                inheritance: z.ZodOptional<z.ZodEnum<{
+                    abstract: "abstract";
+                    default: "default";
+                    sealed: "sealed";
+                }>>;
+                binding: z.ZodOptional<z.ZodObject<{
+                    remoteUrl: z.ZodOptional<z.ZodString>;
+                    route: z.ZodOptional<z.ZodObject<{
+                        method: z.ZodEnum<{
+                            "*": "*";
+                            DELETE: "DELETE";
+                            GET: "GET";
+                            PATCH: "PATCH";
+                            POST: "POST";
+                            PUT: "PUT";
+                        }>;
+                        path: z.ZodString;
+                        self: z.ZodOptional<z.ZodString>;
+                        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        body: z.ZodOptional<z.ZodUnknown>;
+                        credential: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                    auth: z.ZodOptional<z.ZodEnum<{
+                        optional: "optional";
+                        public: "public";
+                        required: "required";
+                    }>>;
+                }, z.core.$strip>>;
+                environment: z.ZodOptional<z.ZodString>;
+                domain: z.ZodOptional<z.ZodString>;
+            };
+            readonly methods: {
+                list: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly methodsOnly: z.ZodOptional<z.ZodBoolean>;
+                }, z.ZodArray<z.ZodObject<{
+                    ref: z.ZodString;
+                    inputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                    outputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                    code: z.ZodOptional<z.ZodObject<{
+                        authenticate: z.ZodOptional<z.ZodString>;
+                        authorize: z.ZodOptional<z.ZodString>;
+                        resolve: z.ZodOptional<z.ZodString>;
+                        invariants: z.ZodOptional<z.ZodString>;
+                        execute: z.ZodOptional<z.ZodString>;
+                        rollback: z.ZodOptional<z.ZodString>;
+                        effects: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    isStatic: z.ZodOptional<z.ZodBoolean>;
+                    output: z.ZodOptional<z.ZodEnum<{
+                        binary: "binary";
+                        stream: "stream";
+                        value: "value";
+                    }>>;
+                    inheritance: z.ZodOptional<z.ZodEnum<{
+                        abstract: "abstract";
+                        default: "default";
+                        sealed: "sealed";
+                    }>>;
+                    binding: z.ZodOptional<z.ZodObject<{
+                        remoteUrl: z.ZodOptional<z.ZodString>;
+                        route: z.ZodOptional<z.ZodObject<{
+                            method: z.ZodEnum<{
+                                "*": "*";
+                                DELETE: "DELETE";
+                                GET: "GET";
+                                PATCH: "PATCH";
+                                POST: "POST";
+                                PUT: "PUT";
+                            }>;
+                            path: z.ZodString;
+                            self: z.ZodOptional<z.ZodString>;
+                            query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            body: z.ZodOptional<z.ZodUnknown>;
+                            credential: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>>;
+                        auth: z.ZodOptional<z.ZodEnum<{
+                            optional: "optional";
+                            public: "public";
+                            required: "required";
+                        }>>;
+                    }, z.core.$strip>>;
+                    environment: z.ZodOptional<z.ZodString>;
+                    domain: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>, "default", true>;
+            };
+        }, "props"> & {
+            readonly properties: {
+                ref: z.ZodString;
+                inputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                outputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                code: z.ZodOptional<z.ZodObject<{
+                    authenticate: z.ZodOptional<z.ZodString>;
+                    authorize: z.ZodOptional<z.ZodString>;
+                    resolve: z.ZodOptional<z.ZodString>;
+                    invariants: z.ZodOptional<z.ZodString>;
+                    execute: z.ZodOptional<z.ZodString>;
+                    rollback: z.ZodOptional<z.ZodString>;
+                    effects: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                isStatic: z.ZodOptional<z.ZodBoolean>;
+                output: z.ZodOptional<z.ZodEnum<{
+                    binary: "binary";
+                    stream: "stream";
+                    value: "value";
+                }>>;
+                inheritance: z.ZodOptional<z.ZodEnum<{
+                    abstract: "abstract";
+                    default: "default";
+                    sealed: "sealed";
+                }>>;
+                binding: z.ZodOptional<z.ZodObject<{
+                    remoteUrl: z.ZodOptional<z.ZodString>;
+                    route: z.ZodOptional<z.ZodObject<{
+                        method: z.ZodEnum<{
+                            "*": "*";
+                            DELETE: "DELETE";
+                            GET: "GET";
+                            PATCH: "PATCH";
+                            POST: "POST";
+                            PUT: "PUT";
+                        }>;
+                        path: z.ZodString;
+                        self: z.ZodOptional<z.ZodString>;
+                        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        body: z.ZodOptional<z.ZodUnknown>;
+                        credential: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                    auth: z.ZodOptional<z.ZodEnum<{
+                        optional: "optional";
+                        public: "public";
+                        required: "required";
+                    }>>;
+                }, z.core.$strip>>;
+                environment: z.ZodOptional<z.ZodString>;
+                domain: z.ZodOptional<z.ZodString>;
+            };
+        } & {
+            readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        createdAt: z.ZodISODateTime;
+                        updatedAt: z.ZodISODateTime;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                        updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                        onConflict: z.ZodOptional<z.ZodEnum<{
+                            defaults: "defaults";
+                            error: "error";
+                            merge: "merge";
+                            replace: "replace";
+                            skip: "skip";
+                        }>>;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        name: z.ZodString;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        description: z.ZodOptional<z.ZodString>;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        status: z.ZodEnum<{
+                            active: "active";
+                            creating: "creating";
+                            deleting: "deleting";
+                            error: "error";
+                            updating: "updating";
+                        }>;
+                    };
+                }>];
+                readonly methods: {
+                    init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                    createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                        readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                    get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                    update: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    }, z.ZodVoid, "default", boolean>;
+                    delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                    deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                    move: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    link: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                        readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    }, z.ZodVoid, "default", boolean>;
+                    unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                        readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                    }, z.ZodVoid, "default", boolean>;
+                    getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                        readonly direction: z.ZodOptional<z.ZodEnum<{
+                            both: "both";
+                            in: "in";
+                            out: "out";
+                        }>>;
+                    }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                    getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly depth: z.ZodNumber;
+                        readonly maxNodes: z.ZodNumber;
+                    }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly methods: {
+                    listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly filters: z.ZodOptional<z.ZodUnknown>;
+                    }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+                    push: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                        readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                };
+            }, "props"> & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly props: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+                readonly methods: {
+                    extendIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly with: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    constrainIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly by: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    excludeIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly without: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExtension: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeConstraint: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExclusion: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    grantPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    revokePerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    checkPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodBoolean, "sealed", boolean>;
+                    registerIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly signingKey: z.ZodOptional<z.ZodObject<{
+                            publicKey: z.ZodObject<{
+                                jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                                jwksUri: z.ZodOptional<z.ZodURL>;
+                            }, z.core.$strip>;
+                            credential: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.ZodObject<{
+                        iss: z.ZodString;
+                        sub: z.ZodString;
+                    }, z.core.$strip>, "sealed", boolean>;
+                    mintIdentityCredential: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodString, "sealed", boolean>;
+                    mintDelegationCredential: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly audience: z.ZodOptional<z.ZodString>;
+                        readonly delegation: z.ZodCustom<import("../..").UnresolvedIdentityExpr, import("../..").UnresolvedIdentityExpr>;
+                        readonly attestation: z.ZodOptional<z.ZodCustom<import("../..").SelfIdentityExpr, import("../..").SelfIdentityExpr>>;
+                        readonly ttl: z.ZodOptional<z.ZodNumber>;
+                    }, z.ZodString, "sealed", boolean>;
+                    findIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly issuer: z.ZodString;
+                        readonly subject: z.ZodString;
+                    }, z.ZodNullable<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", true>;
+                    whoami: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                };
+            }, "props"> & {
+                readonly properties: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+            } & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>];
+        }>];
+        readonly props: {
+            handshake: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                shell: "shell";
+            }>>;
+        };
+    }, "props"> & {
+        readonly properties: {
+            readonly handshake: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                shell: "shell";
+            }>>;
+        };
+    } & {
+        readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                    onConflict: z.ZodOptional<z.ZodEnum<{
+                        defaults: "defaults";
+                        error: "error";
+                        merge: "merge";
+                        replace: "replace";
+                        skip: "skip";
+                    }>>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    name: z.ZodString;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    description: z.ZodOptional<z.ZodString>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    status: z.ZodEnum<{
+                        active: "active";
+                        creating: "creating";
+                        deleting: "deleting";
+                        error: "error";
+                        updating: "updating";
+                    }>;
+                };
+            }>];
+            readonly methods: {
+                init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                update: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.ZodVoid, "default", boolean>;
+                delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                move: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                }, z.ZodVoid, "sealed", boolean>;
+                link: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodVoid, "default", boolean>;
+                unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                }, z.ZodVoid, "default", boolean>;
+                getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                    readonly direction: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        in: "in";
+                        out: "out";
+                    }>>;
+                }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly depth: z.ZodNumber;
+                    readonly maxNodes: z.ZodNumber;
+                }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+            readonly extends: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly methods: {
+                    listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly filters: z.ZodOptional<z.ZodUnknown>;
+                    }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+                    push: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                        readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                };
+            }, "props"> & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly props: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+                readonly methods: {
+                    extendIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly with: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    constrainIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly by: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    excludeIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly without: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExtension: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeConstraint: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExclusion: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    grantPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    revokePerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    checkPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodBoolean, "sealed", boolean>;
+                    registerIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly signingKey: z.ZodOptional<z.ZodObject<{
+                            publicKey: z.ZodObject<{
+                                jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                                jwksUri: z.ZodOptional<z.ZodURL>;
+                            }, z.core.$strip>;
+                            credential: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.ZodObject<{
+                        iss: z.ZodString;
+                        sub: z.ZodString;
+                    }, z.core.$strip>, "sealed", boolean>;
+                    mintIdentityCredential: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodString, "sealed", boolean>;
+                    mintDelegationCredential: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly audience: z.ZodOptional<z.ZodString>;
+                        readonly delegation: z.ZodCustom<import("../..").UnresolvedIdentityExpr, import("../..").UnresolvedIdentityExpr>;
+                        readonly attestation: z.ZodOptional<z.ZodCustom<import("../..").SelfIdentityExpr, import("../..").SelfIdentityExpr>>;
+                        readonly ttl: z.ZodOptional<z.ZodNumber>;
+                    }, z.ZodString, "sealed", boolean>;
+                    findIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly issuer: z.ZodString;
+                        readonly subject: z.ZodString;
+                    }, z.ZodNullable<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", true>;
+                    whoami: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                };
+            }, "props"> & {
+                readonly properties: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+            } & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>];
+            readonly props: {
+                ref: z.ZodString;
+                inputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                outputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                code: z.ZodOptional<z.ZodObject<{
+                    authenticate: z.ZodOptional<z.ZodString>;
+                    authorize: z.ZodOptional<z.ZodString>;
+                    resolve: z.ZodOptional<z.ZodString>;
+                    invariants: z.ZodOptional<z.ZodString>;
+                    execute: z.ZodOptional<z.ZodString>;
+                    rollback: z.ZodOptional<z.ZodString>;
+                    effects: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                isStatic: z.ZodOptional<z.ZodBoolean>;
+                output: z.ZodOptional<z.ZodEnum<{
+                    binary: "binary";
+                    stream: "stream";
+                    value: "value";
+                }>>;
+                inheritance: z.ZodOptional<z.ZodEnum<{
+                    abstract: "abstract";
+                    default: "default";
+                    sealed: "sealed";
+                }>>;
+                binding: z.ZodOptional<z.ZodObject<{
+                    remoteUrl: z.ZodOptional<z.ZodString>;
+                    route: z.ZodOptional<z.ZodObject<{
+                        method: z.ZodEnum<{
+                            "*": "*";
+                            DELETE: "DELETE";
+                            GET: "GET";
+                            PATCH: "PATCH";
+                            POST: "POST";
+                            PUT: "PUT";
+                        }>;
+                        path: z.ZodString;
+                        self: z.ZodOptional<z.ZodString>;
+                        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        body: z.ZodOptional<z.ZodUnknown>;
+                        credential: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                    auth: z.ZodOptional<z.ZodEnum<{
+                        optional: "optional";
+                        public: "public";
+                        required: "required";
+                    }>>;
+                }, z.core.$strip>>;
+                environment: z.ZodOptional<z.ZodString>;
+                domain: z.ZodOptional<z.ZodString>;
+            };
+            readonly methods: {
+                list: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly methodsOnly: z.ZodOptional<z.ZodBoolean>;
+                }, z.ZodArray<z.ZodObject<{
+                    ref: z.ZodString;
+                    inputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                    outputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                    code: z.ZodOptional<z.ZodObject<{
+                        authenticate: z.ZodOptional<z.ZodString>;
+                        authorize: z.ZodOptional<z.ZodString>;
+                        resolve: z.ZodOptional<z.ZodString>;
+                        invariants: z.ZodOptional<z.ZodString>;
+                        execute: z.ZodOptional<z.ZodString>;
+                        rollback: z.ZodOptional<z.ZodString>;
+                        effects: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    isStatic: z.ZodOptional<z.ZodBoolean>;
+                    output: z.ZodOptional<z.ZodEnum<{
+                        binary: "binary";
+                        stream: "stream";
+                        value: "value";
+                    }>>;
+                    inheritance: z.ZodOptional<z.ZodEnum<{
+                        abstract: "abstract";
+                        default: "default";
+                        sealed: "sealed";
+                    }>>;
+                    binding: z.ZodOptional<z.ZodObject<{
+                        remoteUrl: z.ZodOptional<z.ZodString>;
+                        route: z.ZodOptional<z.ZodObject<{
+                            method: z.ZodEnum<{
+                                "*": "*";
+                                DELETE: "DELETE";
+                                GET: "GET";
+                                PATCH: "PATCH";
+                                POST: "POST";
+                                PUT: "PUT";
+                            }>;
+                            path: z.ZodString;
+                            self: z.ZodOptional<z.ZodString>;
+                            query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            body: z.ZodOptional<z.ZodUnknown>;
+                            credential: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>>;
+                        auth: z.ZodOptional<z.ZodEnum<{
+                            optional: "optional";
+                            public: "public";
+                            required: "required";
+                        }>>;
+                    }, z.core.$strip>>;
+                    environment: z.ZodOptional<z.ZodString>;
+                    domain: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>, "default", true>;
+            };
+        }, "props"> & {
+            readonly properties: {
+                ref: z.ZodString;
+                inputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                outputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                code: z.ZodOptional<z.ZodObject<{
+                    authenticate: z.ZodOptional<z.ZodString>;
+                    authorize: z.ZodOptional<z.ZodString>;
+                    resolve: z.ZodOptional<z.ZodString>;
+                    invariants: z.ZodOptional<z.ZodString>;
+                    execute: z.ZodOptional<z.ZodString>;
+                    rollback: z.ZodOptional<z.ZodString>;
+                    effects: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                isStatic: z.ZodOptional<z.ZodBoolean>;
+                output: z.ZodOptional<z.ZodEnum<{
+                    binary: "binary";
+                    stream: "stream";
+                    value: "value";
+                }>>;
+                inheritance: z.ZodOptional<z.ZodEnum<{
+                    abstract: "abstract";
+                    default: "default";
+                    sealed: "sealed";
+                }>>;
+                binding: z.ZodOptional<z.ZodObject<{
+                    remoteUrl: z.ZodOptional<z.ZodString>;
+                    route: z.ZodOptional<z.ZodObject<{
+                        method: z.ZodEnum<{
+                            "*": "*";
+                            DELETE: "DELETE";
+                            GET: "GET";
+                            PATCH: "PATCH";
+                            POST: "POST";
+                            PUT: "PUT";
+                        }>;
+                        path: z.ZodString;
+                        self: z.ZodOptional<z.ZodString>;
+                        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        body: z.ZodOptional<z.ZodUnknown>;
+                        credential: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                    auth: z.ZodOptional<z.ZodEnum<{
+                        optional: "optional";
+                        public: "public";
+                        required: "required";
+                    }>>;
+                }, z.core.$strip>>;
+                environment: z.ZodOptional<z.ZodString>;
+                domain: z.ZodOptional<z.ZodString>;
+            };
+        } & {
+            readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        createdAt: z.ZodISODateTime;
+                        updatedAt: z.ZodISODateTime;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                        updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                        onConflict: z.ZodOptional<z.ZodEnum<{
+                            defaults: "defaults";
+                            error: "error";
+                            merge: "merge";
+                            replace: "replace";
+                            skip: "skip";
+                        }>>;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        name: z.ZodString;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        description: z.ZodOptional<z.ZodString>;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        status: z.ZodEnum<{
+                            active: "active";
+                            creating: "creating";
+                            deleting: "deleting";
+                            error: "error";
+                            updating: "updating";
+                        }>;
+                    };
+                }>];
+                readonly methods: {
+                    init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                    createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                        readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                    get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                    update: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    }, z.ZodVoid, "default", boolean>;
+                    delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                    deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                    move: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    link: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                        readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    }, z.ZodVoid, "default", boolean>;
+                    unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                        readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                    }, z.ZodVoid, "default", boolean>;
+                    getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                        readonly direction: z.ZodOptional<z.ZodEnum<{
+                            both: "both";
+                            in: "in";
+                            out: "out";
+                        }>>;
+                    }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                    getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly depth: z.ZodNumber;
+                        readonly maxNodes: z.ZodNumber;
+                    }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly methods: {
+                    listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly filters: z.ZodOptional<z.ZodUnknown>;
+                    }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+                    push: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                        readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                };
+            }, "props"> & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly props: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+                readonly methods: {
+                    extendIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly with: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    constrainIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly by: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    excludeIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly without: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExtension: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeConstraint: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExclusion: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    grantPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    revokePerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    checkPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodBoolean, "sealed", boolean>;
+                    registerIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly signingKey: z.ZodOptional<z.ZodObject<{
+                            publicKey: z.ZodObject<{
+                                jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                                jwksUri: z.ZodOptional<z.ZodURL>;
+                            }, z.core.$strip>;
+                            credential: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.ZodObject<{
+                        iss: z.ZodString;
+                        sub: z.ZodString;
+                    }, z.core.$strip>, "sealed", boolean>;
+                    mintIdentityCredential: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodString, "sealed", boolean>;
+                    mintDelegationCredential: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly audience: z.ZodOptional<z.ZodString>;
+                        readonly delegation: z.ZodCustom<import("../..").UnresolvedIdentityExpr, import("../..").UnresolvedIdentityExpr>;
+                        readonly attestation: z.ZodOptional<z.ZodCustom<import("../..").SelfIdentityExpr, import("../..").SelfIdentityExpr>>;
+                        readonly ttl: z.ZodOptional<z.ZodNumber>;
+                    }, z.ZodString, "sealed", boolean>;
+                    findIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly issuer: z.ZodString;
+                        readonly subject: z.ZodString;
+                    }, z.ZodNullable<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", true>;
+                    whoami: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                };
+            }, "props"> & {
+                readonly properties: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+            } & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>];
+        }>];
+    }>];
+    readonly icon: string;
+    readonly methods: {
+        resolve: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+        }, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            url: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            handshake: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                shell: "shell";
+            }>>;
+            origin: z.ZodEnum<{
+                class: "class";
+                self: "self";
+            }>;
+        }, z.core.$strip>>, import("@astrale-os/kernel-dsl").MethodInheritance, true>;
+        register: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly targetClass: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+            readonly parent: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+            readonly viewUrl: z.ZodString;
+            readonly name: z.ZodString;
+        }, z.ZodObject<{
+            viewId: z.ZodString;
+            viewPath: z.ZodString;
+        }, z.core.$strip>, import("@astrale-os/kernel-dsl").MethodInheritance, true>;
+    };
+}, "props"> & {
+    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+        readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                createdAt: z.ZodISODateTime;
+                updatedAt: z.ZodISODateTime;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                onConflict: z.ZodOptional<z.ZodEnum<{
+                    defaults: "defaults";
+                    error: "error";
+                    merge: "merge";
+                    replace: "replace";
+                    skip: "skip";
+                }>>;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                name: z.ZodString;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                description: z.ZodOptional<z.ZodString>;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                status: z.ZodEnum<{
+                    active: "active";
+                    creating: "creating";
+                    deleting: "deleting";
+                    error: "error";
+                    updating: "updating";
+                }>;
+            };
+        }>];
+        readonly methods: {
+            init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+            createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+            get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+            update: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.ZodVoid, "default", boolean>;
+            delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+            deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+            move: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+            }, z.ZodVoid, "sealed", boolean>;
+            link: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.ZodVoid, "default", boolean>;
+            unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+            }, z.ZodVoid, "default", boolean>;
+            getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                readonly direction: z.ZodOptional<z.ZodEnum<{
+                    both: "both";
+                    in: "in";
+                    out: "out";
+                }>>;
+            }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+            getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly depth: z.ZodNumber;
+                readonly maxNodes: z.ZodNumber;
+            }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+        };
+    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+        readonly extends: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+            readonly extends: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly methods: {
+                    listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly filters: z.ZodOptional<z.ZodUnknown>;
+                    }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+                    push: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                        readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                };
+            }, "props"> & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly props: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+                readonly methods: {
+                    extendIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly with: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    constrainIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly by: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    excludeIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly without: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExtension: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeConstraint: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExclusion: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    grantPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    revokePerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    checkPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodBoolean, "sealed", boolean>;
+                    registerIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly signingKey: z.ZodOptional<z.ZodObject<{
+                            publicKey: z.ZodObject<{
+                                jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                                jwksUri: z.ZodOptional<z.ZodURL>;
+                            }, z.core.$strip>;
+                            credential: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.ZodObject<{
+                        iss: z.ZodString;
+                        sub: z.ZodString;
+                    }, z.core.$strip>, "sealed", boolean>;
+                    mintIdentityCredential: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodString, "sealed", boolean>;
+                    mintDelegationCredential: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly audience: z.ZodOptional<z.ZodString>;
+                        readonly delegation: z.ZodCustom<import("../..").UnresolvedIdentityExpr, import("../..").UnresolvedIdentityExpr>;
+                        readonly attestation: z.ZodOptional<z.ZodCustom<import("../..").SelfIdentityExpr, import("../..").SelfIdentityExpr>>;
+                        readonly ttl: z.ZodOptional<z.ZodNumber>;
+                    }, z.ZodString, "sealed", boolean>;
+                    findIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly issuer: z.ZodString;
+                        readonly subject: z.ZodString;
+                    }, z.ZodNullable<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", true>;
+                    whoami: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                };
+            }, "props"> & {
+                readonly properties: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+            } & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>];
+            readonly props: {
+                ref: z.ZodString;
+                inputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                outputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                code: z.ZodOptional<z.ZodObject<{
+                    authenticate: z.ZodOptional<z.ZodString>;
+                    authorize: z.ZodOptional<z.ZodString>;
+                    resolve: z.ZodOptional<z.ZodString>;
+                    invariants: z.ZodOptional<z.ZodString>;
+                    execute: z.ZodOptional<z.ZodString>;
+                    rollback: z.ZodOptional<z.ZodString>;
+                    effects: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                isStatic: z.ZodOptional<z.ZodBoolean>;
+                output: z.ZodOptional<z.ZodEnum<{
+                    binary: "binary";
+                    stream: "stream";
+                    value: "value";
+                }>>;
+                inheritance: z.ZodOptional<z.ZodEnum<{
+                    abstract: "abstract";
+                    default: "default";
+                    sealed: "sealed";
+                }>>;
+                binding: z.ZodOptional<z.ZodObject<{
+                    remoteUrl: z.ZodOptional<z.ZodString>;
+                    route: z.ZodOptional<z.ZodObject<{
+                        method: z.ZodEnum<{
+                            "*": "*";
+                            DELETE: "DELETE";
+                            GET: "GET";
+                            PATCH: "PATCH";
+                            POST: "POST";
+                            PUT: "PUT";
+                        }>;
+                        path: z.ZodString;
+                        self: z.ZodOptional<z.ZodString>;
+                        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        body: z.ZodOptional<z.ZodUnknown>;
+                        credential: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                    auth: z.ZodOptional<z.ZodEnum<{
+                        optional: "optional";
+                        public: "public";
+                        required: "required";
+                    }>>;
+                }, z.core.$strip>>;
+                environment: z.ZodOptional<z.ZodString>;
+                domain: z.ZodOptional<z.ZodString>;
+            };
+            readonly methods: {
+                list: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly methodsOnly: z.ZodOptional<z.ZodBoolean>;
+                }, z.ZodArray<z.ZodObject<{
+                    ref: z.ZodString;
+                    inputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                    outputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                    code: z.ZodOptional<z.ZodObject<{
+                        authenticate: z.ZodOptional<z.ZodString>;
+                        authorize: z.ZodOptional<z.ZodString>;
+                        resolve: z.ZodOptional<z.ZodString>;
+                        invariants: z.ZodOptional<z.ZodString>;
+                        execute: z.ZodOptional<z.ZodString>;
+                        rollback: z.ZodOptional<z.ZodString>;
+                        effects: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    isStatic: z.ZodOptional<z.ZodBoolean>;
+                    output: z.ZodOptional<z.ZodEnum<{
+                        binary: "binary";
+                        stream: "stream";
+                        value: "value";
+                    }>>;
+                    inheritance: z.ZodOptional<z.ZodEnum<{
+                        abstract: "abstract";
+                        default: "default";
+                        sealed: "sealed";
+                    }>>;
+                    binding: z.ZodOptional<z.ZodObject<{
+                        remoteUrl: z.ZodOptional<z.ZodString>;
+                        route: z.ZodOptional<z.ZodObject<{
+                            method: z.ZodEnum<{
+                                "*": "*";
+                                DELETE: "DELETE";
+                                GET: "GET";
+                                PATCH: "PATCH";
+                                POST: "POST";
+                                PUT: "PUT";
+                            }>;
+                            path: z.ZodString;
+                            self: z.ZodOptional<z.ZodString>;
+                            query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            body: z.ZodOptional<z.ZodUnknown>;
+                            credential: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>>;
+                        auth: z.ZodOptional<z.ZodEnum<{
+                            optional: "optional";
+                            public: "public";
+                            required: "required";
+                        }>>;
+                    }, z.core.$strip>>;
+                    environment: z.ZodOptional<z.ZodString>;
+                    domain: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>, "default", true>;
+            };
+        }, "props"> & {
+            readonly properties: {
+                ref: z.ZodString;
+                inputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                outputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                code: z.ZodOptional<z.ZodObject<{
+                    authenticate: z.ZodOptional<z.ZodString>;
+                    authorize: z.ZodOptional<z.ZodString>;
+                    resolve: z.ZodOptional<z.ZodString>;
+                    invariants: z.ZodOptional<z.ZodString>;
+                    execute: z.ZodOptional<z.ZodString>;
+                    rollback: z.ZodOptional<z.ZodString>;
+                    effects: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                isStatic: z.ZodOptional<z.ZodBoolean>;
+                output: z.ZodOptional<z.ZodEnum<{
+                    binary: "binary";
+                    stream: "stream";
+                    value: "value";
+                }>>;
+                inheritance: z.ZodOptional<z.ZodEnum<{
+                    abstract: "abstract";
+                    default: "default";
+                    sealed: "sealed";
+                }>>;
+                binding: z.ZodOptional<z.ZodObject<{
+                    remoteUrl: z.ZodOptional<z.ZodString>;
+                    route: z.ZodOptional<z.ZodObject<{
+                        method: z.ZodEnum<{
+                            "*": "*";
+                            DELETE: "DELETE";
+                            GET: "GET";
+                            PATCH: "PATCH";
+                            POST: "POST";
+                            PUT: "PUT";
+                        }>;
+                        path: z.ZodString;
+                        self: z.ZodOptional<z.ZodString>;
+                        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        body: z.ZodOptional<z.ZodUnknown>;
+                        credential: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                    auth: z.ZodOptional<z.ZodEnum<{
+                        optional: "optional";
+                        public: "public";
+                        required: "required";
+                    }>>;
+                }, z.core.$strip>>;
+                environment: z.ZodOptional<z.ZodString>;
+                domain: z.ZodOptional<z.ZodString>;
+            };
+        } & {
+            readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        createdAt: z.ZodISODateTime;
+                        updatedAt: z.ZodISODateTime;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                        updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                        onConflict: z.ZodOptional<z.ZodEnum<{
+                            defaults: "defaults";
+                            error: "error";
+                            merge: "merge";
+                            replace: "replace";
+                            skip: "skip";
+                        }>>;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        name: z.ZodString;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        description: z.ZodOptional<z.ZodString>;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        status: z.ZodEnum<{
+                            active: "active";
+                            creating: "creating";
+                            deleting: "deleting";
+                            error: "error";
+                            updating: "updating";
+                        }>;
+                    };
+                }>];
+                readonly methods: {
+                    init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                    createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                        readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                    get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                    update: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    }, z.ZodVoid, "default", boolean>;
+                    delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                    deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                    move: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    link: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                        readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    }, z.ZodVoid, "default", boolean>;
+                    unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                        readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                    }, z.ZodVoid, "default", boolean>;
+                    getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                        readonly direction: z.ZodOptional<z.ZodEnum<{
+                            both: "both";
+                            in: "in";
+                            out: "out";
+                        }>>;
+                    }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                    getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly depth: z.ZodNumber;
+                        readonly maxNodes: z.ZodNumber;
+                    }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly methods: {
+                    listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly filters: z.ZodOptional<z.ZodUnknown>;
+                    }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+                    push: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                        readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                };
+            }, "props"> & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly props: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+                readonly methods: {
+                    extendIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly with: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    constrainIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly by: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    excludeIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly without: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExtension: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeConstraint: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExclusion: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    grantPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    revokePerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    checkPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodBoolean, "sealed", boolean>;
+                    registerIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly signingKey: z.ZodOptional<z.ZodObject<{
+                            publicKey: z.ZodObject<{
+                                jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                                jwksUri: z.ZodOptional<z.ZodURL>;
+                            }, z.core.$strip>;
+                            credential: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.ZodObject<{
+                        iss: z.ZodString;
+                        sub: z.ZodString;
+                    }, z.core.$strip>, "sealed", boolean>;
+                    mintIdentityCredential: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodString, "sealed", boolean>;
+                    mintDelegationCredential: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly audience: z.ZodOptional<z.ZodString>;
+                        readonly delegation: z.ZodCustom<import("../..").UnresolvedIdentityExpr, import("../..").UnresolvedIdentityExpr>;
+                        readonly attestation: z.ZodOptional<z.ZodCustom<import("../..").SelfIdentityExpr, import("../..").SelfIdentityExpr>>;
+                        readonly ttl: z.ZodOptional<z.ZodNumber>;
+                    }, z.ZodString, "sealed", boolean>;
+                    findIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly issuer: z.ZodString;
+                        readonly subject: z.ZodString;
+                    }, z.ZodNullable<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", true>;
+                    whoami: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                };
+            }, "props"> & {
+                readonly properties: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+            } & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>];
+        }>];
+        readonly props: {
+            handshake: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                shell: "shell";
+            }>>;
+        };
+    }, "props"> & {
+        readonly properties: {
+            readonly handshake: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                shell: "shell";
+            }>>;
+        };
+    } & {
+        readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                    onConflict: z.ZodOptional<z.ZodEnum<{
+                        defaults: "defaults";
+                        error: "error";
+                        merge: "merge";
+                        replace: "replace";
+                        skip: "skip";
+                    }>>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    name: z.ZodString;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    description: z.ZodOptional<z.ZodString>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    status: z.ZodEnum<{
+                        active: "active";
+                        creating: "creating";
+                        deleting: "deleting";
+                        error: "error";
+                        updating: "updating";
+                    }>;
+                };
+            }>];
+            readonly methods: {
+                init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                update: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.ZodVoid, "default", boolean>;
+                delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                move: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                }, z.ZodVoid, "sealed", boolean>;
+                link: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodVoid, "default", boolean>;
+                unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                }, z.ZodVoid, "default", boolean>;
+                getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                    readonly direction: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        in: "in";
+                        out: "out";
+                    }>>;
+                }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly depth: z.ZodNumber;
+                    readonly maxNodes: z.ZodNumber;
+                }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+            readonly extends: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly methods: {
+                    listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly filters: z.ZodOptional<z.ZodUnknown>;
+                    }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+                    push: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                        readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                };
+            }, "props"> & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly props: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+                readonly methods: {
+                    extendIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly with: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    constrainIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly by: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    excludeIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly without: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExtension: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeConstraint: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExclusion: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    grantPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    revokePerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    checkPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodBoolean, "sealed", boolean>;
+                    registerIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly signingKey: z.ZodOptional<z.ZodObject<{
+                            publicKey: z.ZodObject<{
+                                jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                                jwksUri: z.ZodOptional<z.ZodURL>;
+                            }, z.core.$strip>;
+                            credential: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.ZodObject<{
+                        iss: z.ZodString;
+                        sub: z.ZodString;
+                    }, z.core.$strip>, "sealed", boolean>;
+                    mintIdentityCredential: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodString, "sealed", boolean>;
+                    mintDelegationCredential: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly audience: z.ZodOptional<z.ZodString>;
+                        readonly delegation: z.ZodCustom<import("../..").UnresolvedIdentityExpr, import("../..").UnresolvedIdentityExpr>;
+                        readonly attestation: z.ZodOptional<z.ZodCustom<import("../..").SelfIdentityExpr, import("../..").SelfIdentityExpr>>;
+                        readonly ttl: z.ZodOptional<z.ZodNumber>;
+                    }, z.ZodString, "sealed", boolean>;
+                    findIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly issuer: z.ZodString;
+                        readonly subject: z.ZodString;
+                    }, z.ZodNullable<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", true>;
+                    whoami: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                };
+            }, "props"> & {
+                readonly properties: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+            } & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>];
+            readonly props: {
+                ref: z.ZodString;
+                inputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                outputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                code: z.ZodOptional<z.ZodObject<{
+                    authenticate: z.ZodOptional<z.ZodString>;
+                    authorize: z.ZodOptional<z.ZodString>;
+                    resolve: z.ZodOptional<z.ZodString>;
+                    invariants: z.ZodOptional<z.ZodString>;
+                    execute: z.ZodOptional<z.ZodString>;
+                    rollback: z.ZodOptional<z.ZodString>;
+                    effects: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                isStatic: z.ZodOptional<z.ZodBoolean>;
+                output: z.ZodOptional<z.ZodEnum<{
+                    binary: "binary";
+                    stream: "stream";
+                    value: "value";
+                }>>;
+                inheritance: z.ZodOptional<z.ZodEnum<{
+                    abstract: "abstract";
+                    default: "default";
+                    sealed: "sealed";
+                }>>;
+                binding: z.ZodOptional<z.ZodObject<{
+                    remoteUrl: z.ZodOptional<z.ZodString>;
+                    route: z.ZodOptional<z.ZodObject<{
+                        method: z.ZodEnum<{
+                            "*": "*";
+                            DELETE: "DELETE";
+                            GET: "GET";
+                            PATCH: "PATCH";
+                            POST: "POST";
+                            PUT: "PUT";
+                        }>;
+                        path: z.ZodString;
+                        self: z.ZodOptional<z.ZodString>;
+                        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        body: z.ZodOptional<z.ZodUnknown>;
+                        credential: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                    auth: z.ZodOptional<z.ZodEnum<{
+                        optional: "optional";
+                        public: "public";
+                        required: "required";
+                    }>>;
+                }, z.core.$strip>>;
+                environment: z.ZodOptional<z.ZodString>;
+                domain: z.ZodOptional<z.ZodString>;
+            };
+            readonly methods: {
+                list: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly methodsOnly: z.ZodOptional<z.ZodBoolean>;
+                }, z.ZodArray<z.ZodObject<{
+                    ref: z.ZodString;
+                    inputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                    outputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                    code: z.ZodOptional<z.ZodObject<{
+                        authenticate: z.ZodOptional<z.ZodString>;
+                        authorize: z.ZodOptional<z.ZodString>;
+                        resolve: z.ZodOptional<z.ZodString>;
+                        invariants: z.ZodOptional<z.ZodString>;
+                        execute: z.ZodOptional<z.ZodString>;
+                        rollback: z.ZodOptional<z.ZodString>;
+                        effects: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    isStatic: z.ZodOptional<z.ZodBoolean>;
+                    output: z.ZodOptional<z.ZodEnum<{
+                        binary: "binary";
+                        stream: "stream";
+                        value: "value";
+                    }>>;
+                    inheritance: z.ZodOptional<z.ZodEnum<{
+                        abstract: "abstract";
+                        default: "default";
+                        sealed: "sealed";
+                    }>>;
+                    binding: z.ZodOptional<z.ZodObject<{
+                        remoteUrl: z.ZodOptional<z.ZodString>;
+                        route: z.ZodOptional<z.ZodObject<{
+                            method: z.ZodEnum<{
+                                "*": "*";
+                                DELETE: "DELETE";
+                                GET: "GET";
+                                PATCH: "PATCH";
+                                POST: "POST";
+                                PUT: "PUT";
+                            }>;
+                            path: z.ZodString;
+                            self: z.ZodOptional<z.ZodString>;
+                            query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            body: z.ZodOptional<z.ZodUnknown>;
+                            credential: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>>;
+                        auth: z.ZodOptional<z.ZodEnum<{
+                            optional: "optional";
+                            public: "public";
+                            required: "required";
+                        }>>;
+                    }, z.core.$strip>>;
+                    environment: z.ZodOptional<z.ZodString>;
+                    domain: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>, "default", true>;
+            };
+        }, "props"> & {
+            readonly properties: {
+                ref: z.ZodString;
+                inputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                outputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+                code: z.ZodOptional<z.ZodObject<{
+                    authenticate: z.ZodOptional<z.ZodString>;
+                    authorize: z.ZodOptional<z.ZodString>;
+                    resolve: z.ZodOptional<z.ZodString>;
+                    invariants: z.ZodOptional<z.ZodString>;
+                    execute: z.ZodOptional<z.ZodString>;
+                    rollback: z.ZodOptional<z.ZodString>;
+                    effects: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                isStatic: z.ZodOptional<z.ZodBoolean>;
+                output: z.ZodOptional<z.ZodEnum<{
+                    binary: "binary";
+                    stream: "stream";
+                    value: "value";
+                }>>;
+                inheritance: z.ZodOptional<z.ZodEnum<{
+                    abstract: "abstract";
+                    default: "default";
+                    sealed: "sealed";
+                }>>;
+                binding: z.ZodOptional<z.ZodObject<{
+                    remoteUrl: z.ZodOptional<z.ZodString>;
+                    route: z.ZodOptional<z.ZodObject<{
+                        method: z.ZodEnum<{
+                            "*": "*";
+                            DELETE: "DELETE";
+                            GET: "GET";
+                            PATCH: "PATCH";
+                            POST: "POST";
+                            PUT: "PUT";
+                        }>;
+                        path: z.ZodString;
+                        self: z.ZodOptional<z.ZodString>;
+                        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        body: z.ZodOptional<z.ZodUnknown>;
+                        credential: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                    auth: z.ZodOptional<z.ZodEnum<{
+                        optional: "optional";
+                        public: "public";
+                        required: "required";
+                    }>>;
+                }, z.core.$strip>>;
+                environment: z.ZodOptional<z.ZodString>;
+                domain: z.ZodOptional<z.ZodString>;
+            };
+        } & {
+            readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        createdAt: z.ZodISODateTime;
+                        updatedAt: z.ZodISODateTime;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                        updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                        onConflict: z.ZodOptional<z.ZodEnum<{
+                            defaults: "defaults";
+                            error: "error";
+                            merge: "merge";
+                            replace: "replace";
+                            skip: "skip";
+                        }>>;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        name: z.ZodString;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        description: z.ZodOptional<z.ZodString>;
+                    };
+                }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly properties: {
+                        status: z.ZodEnum<{
+                            active: "active";
+                            creating: "creating";
+                            deleting: "deleting";
+                            error: "error";
+                            updating: "updating";
+                        }>;
+                    };
+                }>];
+                readonly methods: {
+                    init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                    createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                        readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                    get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                    update: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    }, z.ZodVoid, "default", boolean>;
+                    delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                    deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                    move: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    link: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                        readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    }, z.ZodVoid, "default", boolean>;
+                    unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                        readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                    }, z.ZodVoid, "default", boolean>;
+                    getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                        readonly direction: z.ZodOptional<z.ZodEnum<{
+                            both: "both";
+                            in: "in";
+                            out: "out";
+                        }>>;
+                    }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                    getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly depth: z.ZodNumber;
+                        readonly maxNodes: z.ZodNumber;
+                    }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly methods: {
+                    listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly filters: z.ZodOptional<z.ZodUnknown>;
+                    }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+                    push: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                        readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                };
+            }, "props"> & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+                readonly props: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+                readonly methods: {
+                    extendIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly with: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    constrainIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly by: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    excludeIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly without: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExtension: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeConstraint: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    removeExclusion: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly identity: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    grantPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    revokePerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodVoid, "sealed", boolean>;
+                    checkPerm: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly node: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                        readonly perms: z.ZodNumber;
+                    }, z.ZodBoolean, "sealed", boolean>;
+                    registerIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly signingKey: z.ZodOptional<z.ZodObject<{
+                            publicKey: z.ZodObject<{
+                                jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                                jwksUri: z.ZodOptional<z.ZodURL>;
+                            }, z.core.$strip>;
+                            credential: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.ZodObject<{
+                        iss: z.ZodString;
+                        sub: z.ZodString;
+                    }, z.core.$strip>, "sealed", boolean>;
+                    mintIdentityCredential: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodString, "sealed", boolean>;
+                    mintDelegationCredential: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly audience: z.ZodOptional<z.ZodString>;
+                        readonly delegation: z.ZodCustom<import("../..").UnresolvedIdentityExpr, import("../..").UnresolvedIdentityExpr>;
+                        readonly attestation: z.ZodOptional<z.ZodCustom<import("../..").SelfIdentityExpr, import("../..").SelfIdentityExpr>>;
+                        readonly ttl: z.ZodOptional<z.ZodNumber>;
+                    }, z.ZodString, "sealed", boolean>;
+                    findIdentity: import("@astrale-os/kernel-dsl").FnDef<{
+                        readonly issuer: z.ZodString;
+                        readonly subject: z.ZodString;
+                    }, z.ZodNullable<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", true>;
+                    whoami: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                };
+            }, "props"> & {
+                readonly properties: {
+                    iss: z.ZodString;
+                    sub: z.ZodString;
+                    frozen: z.ZodOptional<z.ZodBoolean>;
+                    publicKey: z.ZodOptional<z.ZodObject<{
+                        jwk: z.ZodOptional<z.ZodCustom<import("jose").JWK, import("jose").JWK>>;
+                        jwksUri: z.ZodOptional<z.ZodURL>;
+                    }, z.core.$strip>>;
+                    requiredClaims: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"eq">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"contains">;
+                        value: z.ZodType<import("../..").JsonValue, unknown, z.core.$ZodTypeInternals<import("../..").JsonValue, unknown>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        claim: z.ZodString;
+                        op: z.ZodLiteral<"exists">;
+                    }, z.core.$strip>], "op">>>;
+                };
+            } & {
+                readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            createdAt: z.ZodISODateTime;
+                            updatedAt: z.ZodISODateTime;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                            updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                            onConflict: z.ZodOptional<z.ZodEnum<{
+                                defaults: "defaults";
+                                error: "error";
+                                merge: "merge";
+                                replace: "replace";
+                                skip: "skip";
+                            }>>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            name: z.ZodString;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            description: z.ZodOptional<z.ZodString>;
+                        };
+                    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                        readonly properties: {
+                            status: z.ZodEnum<{
+                                active: "active";
+                                creating: "creating";
+                                deleting: "deleting";
+                                error: "error";
+                                updating: "updating";
+                            }>;
+                        };
+                    }>];
+                    readonly methods: {
+                        init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                        createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                        get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                        update: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        }, z.ZodVoid, "default", boolean>;
+                        delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                        deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                        move: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                        }, z.ZodVoid, "sealed", boolean>;
+                        link: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                            readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                            readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                            readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                        }, z.ZodVoid, "default", boolean>;
+                        getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                            readonly direction: z.ZodOptional<z.ZodEnum<{
+                                both: "both";
+                                in: "in";
+                                out: "out";
+                            }>>;
+                        }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                        getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                            readonly depth: z.ZodNumber;
+                            readonly maxNodes: z.ZodNumber;
+                        }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+                    };
+                }>];
+            }>];
+        }>];
+    }>];
+}>;
+//# sourceMappingURL=View.class.d.ts.map