@astrale-os/kernel-core 0.4.1

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

@@ -0,0 +1,1667 @@
+import z from 'zod';
+/**
+ * `Function` — the canonical node class for every callable in the kernel graph.
+ *
+ * Materialized from a schema method declaration (`Class.foo` / `Interface.bar`),
+ * the resulting node carries the full Function-interface contract (ref, schemas,
+ * code hooks, optional binding). The dispatcher branches on `binding.remoteUrl`
+ * to decide between remote redirect and in-sandbox execution.
+ *
+ * One node class covers every non-UI callable: a function attached to a class
+ * via `method_of` (addressed as a method — see `MethodPath`) and a free-standing
+ * remote endpoint (the former `RemoteFunction`, distinguished only by carrying a
+ * `binding.remoteUrl`). Replaces the historic `Syscall` / `Method` /
+ * `RemoteFunction` classes — there's no separation between "kernel-internal" and
+ * "domain" callables at the node-class level. The distinction lives at the owner
+ * level (kernel-owned vs non-kernel-owned) and at the SDK API level (which
+ * forbids non-kernel domain authors from setting `code.*` hooks).
+ *
+ * Shares its name with the `Function` interface (separate namespaces). The flat
+ * `K` accessor does NOT resolve this homonym — `K.Function` fails to type-check;
+ * reference this class via `K.$.c('Function')` and the interface via
+ * `K.$.i('Function')`.
+ */
+export declare const Function: 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 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: {
+        init: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly parent: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+            readonly slug: z.ZodString;
+            readonly inputSchema: z.ZodOptional<z.ZodString>;
+            readonly outputSchema: z.ZodOptional<z.ZodString>;
+            readonly class: z.ZodOptional<z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>>;
+            readonly interface: z.ZodOptional<z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>>;
+        }, z.ZodVoid, 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 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=Function.class.d.ts.map