npm - @astrale-os/kernel-core - Versions diffs - 0.9.0-beta.53 → 0.9.0-beta.55 - Mend

@astrale-os/kernel-core 0.9.0-beta.53 → 0.9.0-beta.55

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (52) hide show

package/dist/schema/kernel/schema.d.ts CHANGED Viewed

@@ -97,7 +97,7 @@ declare const KernelDefinitions: {
                     principal: string;
                     audience: string;
                     ttlSeconds: number;
-                    attenuation: unknown;
+                    attenuation?: unknown;
                 }, {
                     readonly mode: 'value';
                     readonly value: string;
@@ -230,6 +230,21 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -256,26 +271,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -481,7 +481,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -625,7 +625,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -754,6 +754,21 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -780,26 +795,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -852,7 +852,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -981,6 +981,21 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -1007,26 +1022,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -1079,7 +1079,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -1208,6 +1208,21 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -1234,26 +1249,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -1306,7 +1306,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -1435,6 +1435,21 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -1461,26 +1476,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -1553,7 +1553,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -1682,6 +1682,21 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -1708,26 +1723,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -1745,29 +1745,14 @@ declare const KernelDefinitions: {
                     }[];
                 };
             }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                iss: string;
-                sub: string;
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
             }, {
                 readonly mode: 'value';
-                readonly value: {
-                    id: string;
-                    iss: string;
-                    sub: string;
-                    frozen: boolean;
-                    requiredClaims: ({
-                        claim: string;
-                        op: "contains";
-                        value: unknown;
-                    } | {
-                        claim: string;
-                        op: "eq";
-                        value: unknown;
-                    } | {
-                        claim: string;
-                        op: "exists";
-                    })[];
-                } | null;
-            }, "authorized", true, false>>, "whois", builder.ClassOwnerProjection<"node", {
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", builder.ClassOwnerProjection<"node", {
                 readonly abstract: true;
                 readonly depth: 1;
                 readonly properties: {
@@ -1803,7 +1788,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -1932,6 +1917,21 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -1958,26 +1958,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -1995,14 +1980,13 @@ declare const KernelDefinitions: {
                     }[];
                 };
             }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                principal: string;
-                audience: string;
+                audience?: string | undefined;
                 ttlSeconds: number;
-                attenuation: unknown;
+                grant?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "delegate", builder.ClassOwnerProjection<"node", {
+            }, "authenticated", true, false>>, "mint", builder.ClassOwnerProjection<"node", {
                 readonly abstract: true;
                 readonly depth: 1;
                 readonly properties: {
@@ -2038,7 +2022,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -2167,17 +2151,32 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                iss: string;
-                sub: string;
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
             }, {
                 readonly mode: 'value';
-                readonly value: {
-                    id: string;
-                    iss: string;
-                    sub: string;
-                    frozen: boolean;
-                    requiredClaims: ({
-                        claim: string;
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
                         op: "contains";
                         value: unknown;
                     } | {
@@ -2193,26 +2192,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -2230,13 +2214,29 @@ declare const KernelDefinitions: {
                     }[];
                 };
             }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
+                iss: string;
+                sub: string;
             }, {
                 readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", builder.ClassOwnerProjection<"node", {
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", builder.ClassOwnerProjection<"node", {
                 readonly abstract: true;
                 readonly depth: 1;
                 readonly properties: {
@@ -2272,7 +2272,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -2401,6 +2401,21 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -2427,26 +2442,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -2464,14 +2464,14 @@ declare const KernelDefinitions: {
                     }[];
                 };
             }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
+                principal: string;
+                audience: string;
                 ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authorized", true, false>>, "impersonate", builder.ClassOwnerProjection<"node", {
+            }, "authenticated", true, false>>, "delegate", builder.ClassOwnerProjection<"node", {
                 readonly abstract: true;
                 readonly depth: 1;
                 readonly properties: {
@@ -2507,7 +2507,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -2636,6 +2636,21 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -2662,26 +2677,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -2751,7 +2751,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -2880,6 +2880,21 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -2906,26 +2921,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -3008,7 +3008,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -3137,6 +3137,21 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -3163,26 +3178,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -3235,7 +3235,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -3364,6 +3364,21 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -3390,26 +3405,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -3462,7 +3462,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -3591,6 +3591,21 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -3617,26 +3632,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -3689,7 +3689,7 @@ declare const KernelDefinitions: {
                         principal: string;
                         audience: string;
                         ttlSeconds: number;
-                        attenuation: unknown;
+                        attenuation?: unknown;
                     }, {
                         readonly mode: 'value';
                         readonly value: string;
@@ -3818,6 +3818,3508 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "dependencyContext", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "origin", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schema", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schemaRevision", "self", never>);
+            readonly abstractInstanceMethods: never;
+            readonly abstractStaticMethods: never;
+            readonly effectiveInstanceMethods: never;
+            readonly effectiveStaticMethods: never;
+        }>;
+        readonly Function: builder.NodeClass<{
+            readonly depth: 2;
+            readonly abstract: false;
+            readonly extends: readonly [builder.ClassReferenceProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
+                };
+                readonly methods: Readonly<Record<never, never>>;
+            }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
+                };
+                readonly methods: Readonly<Record<never, never>>;
+            }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never>, never, never>, builder.ClassReferenceProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>>>];
+            readonly properties: {
+                readonly kind: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "kind", "self", undefined>;
+                readonly input: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "input", "self", undefined>;
+                readonly output: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "output", "self", undefined>;
+                readonly auth: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "auth", "self", undefined>;
+                readonly policy: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "policy", "self", never>;
+                readonly static: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "static", "self", never>;
+                readonly abstract: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "abstract", "self", never>;
+            };
+            readonly methods: Readonly<{
+                admit: builder.Method<builder.CallableProjection<{
+                    call: {
+                        target: string | {
+                            callable: string;
+                            instance?: string | undefined;
+                            revision?: string | undefined;
+                            fingerprint?: string | undefined;
+                        };
+                        input: unknown;
+                    };
+                    credential?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        callable: string;
+                        receiver?: string | undefined;
+                    };
+                }, "authenticated", true, false>>;
+            }>;
+            readonly effectiveProperties: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
+                };
+                readonly methods: Readonly<Record<never, never>>;
+            }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", builder.ClassOwnerProjection<"node", {
+                readonly abstract: true;
+                readonly depth: 1;
+                readonly properties: {
+                    readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+                    readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+                    readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+                    readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false, "requiredClaims", "self", never>;
+                };
+                readonly methods: Readonly<{
+                    delegate: builder.Method<builder.CallableProjection<{
+                        principal: string;
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    can: builder.Method<builder.CallableProjection<{
+                        policy: string;
+                        object: string;
+                    } | {
+                        checks: {
+                            policy: string;
+                            object: string;
+                        }[];
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        } | {
+                            decisions: {
+                                allowed: boolean;
+                            }[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, "authenticated", true, false>>;
+                    whois: builder.Method<builder.CallableProjection<{
+                        iss: string;
+                        sub: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            iss: string;
+                            sub: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, "authorized", true, false>>;
+                    mint: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authenticated", true, false>>;
+                    impersonate: builder.Method<builder.CallableProjection<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                        identity: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, "authorized", true, false>>;
+                }>;
+            }, builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -3844,26 +7346,11 @@ declare const KernelDefinitions: {
                 principal: string;
                 audience: string;
                 ttlSeconds: number;
-                attenuation: unknown;
+                attenuation?: unknown;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-                identity: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             } | {
@@ -3880,67 +7367,7 @@ declare const KernelDefinitions: {
                         allowed: boolean;
                     }[];
                 };
-            }, "authenticated", true, false>>, "can", unknown>>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "dependencyContext", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "origin", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schema", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schemaRevision", "self", never>);
-            readonly abstractInstanceMethods: never;
-            readonly abstractStaticMethods: never;
-            readonly effectiveInstanceMethods: never;
-            readonly effectiveStaticMethods: never;
-        }>;
-        readonly Function: builder.NodeClass<{
-            readonly depth: 2;
-            readonly abstract: false;
-            readonly extends: readonly [builder.ClassReferenceProjection<"node", {
-                readonly abstract: true;
-                readonly depth: 1;
-                readonly properties: {
-                    readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
-                };
-                readonly methods: Readonly<Record<never, never>>;
-            }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
-                readonly abstract: true;
-                readonly depth: 1;
-                readonly properties: {
-                    readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
-                };
-                readonly methods: Readonly<Record<never, never>>;
-            }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never>, never, never>];
-            readonly properties: {
-                readonly kind: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "kind", "self", undefined>;
-                readonly input: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "input", "self", undefined>;
-                readonly output: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "output", "self", undefined>;
-                readonly auth: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "auth", "self", undefined>;
-                readonly policy: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "policy", "self", never>;
-                readonly static: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "static", "self", never>;
-                readonly abstract: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "abstract", "self", never>;
-            };
-            readonly methods: Readonly<{
-                admit: builder.Method<builder.CallableProjection<{
-                    call: {
-                        target: string | {
-                            callable: string;
-                            instance?: string | undefined;
-                            revision?: string | undefined;
-                            fingerprint?: string | undefined;
-                        };
-                        input: unknown;
-                    };
-                    credential?: string | undefined;
-                }, {
-                    readonly mode: 'value';
-                    readonly value: {
-                        callable: string;
-                        receiver?: string | undefined;
-                    };
-                }, "authenticated", true, false>>;
-            }>;
-            readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
-                readonly abstract: true;
-                readonly depth: 1;
-                readonly properties: {
-                    readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
-                };
-                readonly methods: Readonly<Record<never, never>>;
-            }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "abstract", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "auth", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "input", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "kind", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "output", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "policy", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "static", "self", never>);
+            }, "authenticated", true, false>>, "can", unknown>>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "abstract", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "auth", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "input", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "kind", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "output", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "policy", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "static", "self", never>);
             readonly abstractInstanceMethods: never;
             readonly abstractStaticMethods: never;
             readonly effectiveInstanceMethods: never;
@@ -4569,6 +7996,26 @@ declare const KernelDefinitions: {
                 };
             };
         }, "authorized", false, false>>;
+        upload: builder.Function<builder.CallableProjection<import("@astrale-os/kernel-dsl/v1").BinaryInputProjection<{
+            mediaType: string;
+        }>, {
+            readonly mode: 'value';
+            readonly value: {
+                receipt: string;
+                ref: {
+                    digest: string;
+                    mediaType: string;
+                    size: number;
+                };
+                expiresAt: string;
+            };
+        }, "authorized", false, false>>;
+        download: builder.Function<builder.CallableProjection<{
+            node: string;
+            property: string;
+        }, {
+            readonly mode: 'binary';
+        }, "authorized", false, false>>;
         mutate: builder.Function<builder.CallableProjection<{
             ast: {
                 format: "astrale.graph.mutation";
@@ -4725,6 +8172,29 @@ declare const KernelDefinitions: {
                     };
                 })[];
                 operations: ({
+                    op: "edge.update";
+                    edge: {
+                        source: string;
+                        target: string;
+                        class: string;
+                    };
+                    slug: unknown;
+                    props?: {
+                        set: Record<string, unknown>;
+                        unset: string[];
+                    } | undefined;
+                } | {
+                    op: "edge.update";
+                    edge: {
+                        source: string;
+                        target: string;
+                        class: string;
+                    };
+                    props: {
+                        set: Record<string, unknown>;
+                        unset: string[];
+                    };
+                } | {
                     op: "node.create";
                     as: string;
                     class: string;
@@ -4752,29 +8222,6 @@ declare const KernelDefinitions: {
                     };
                     slug?: unknown;
                     props: Record<string, unknown>;
-                } | {
-                    op: "edge.update";
-                    edge: {
-                        source: string;
-                        target: string;
-                        class: string;
-                    };
-                    slug: unknown;
-                    props?: {
-                        set: Record<string, unknown>;
-                        unset: string[];
-                    } | undefined;
-                } | {
-                    op: "edge.update";
-                    edge: {
-                        source: string;
-                        target: string;
-                        class: string;
-                    };
-                    props: {
-                        set: Record<string, unknown>;
-                        unset: string[];
-                    };
                 } | {
                     op: "edge.delete";
                     edge: {
@@ -5199,6 +8646,16 @@ export declare const AuthorityRelations: Readonly<{
 }>;
 /** Exact authorized Kernel Functions for which pristine Root receives direct can_use authority. */
 export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
+    node: string;
+    property: string;
+}, {
+    readonly mode: 'binary';
+}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"download"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.download";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     operation: string;
     domains: ({
         artifact: {
@@ -5411,6 +8868,29 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
             };
         })[];
         operations: ({
+            op: "edge.update";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
+            };
+            slug: unknown;
+            props?: {
+                set: Record<string, unknown>;
+                unset: string[];
+            } | undefined;
+        } | {
+            op: "edge.update";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
+            };
+            props: {
+                set: Record<string, unknown>;
+                unset: string[];
+            };
+        } | {
             op: "node.create";
             as: string;
             class: string;
@@ -5438,29 +8918,6 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
             };
             slug?: unknown;
             props: Record<string, unknown>;
-        } | {
-            op: "edge.update";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
-            };
-            slug: unknown;
-            props?: {
-                set: Record<string, unknown>;
-                unset: string[];
-            } | undefined;
-        } | {
-            op: "edge.update";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
-            };
-            props: {
-                set: Record<string, unknown>;
-                unset: string[];
-            };
         } | {
             op: "edge.delete";
             edge: {
@@ -5782,6 +9239,24 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
         readonly origin: "kernel.astrale.ai";
     };
     readonly key: "kernel.astrale.ai:function.uninstall";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<import("@astrale-os/kernel-dsl/v1").BinaryInputProjection<{
+    mediaType: string;
+}>, {
+    readonly mode: 'value';
+    readonly value: {
+        receipt: string;
+        ref: {
+            digest: string;
+            mediaType: string;
+            size: number;
+        };
+        expiresAt: string;
+    };
+}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"upload"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.upload";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
     audience?: string | undefined;
     ttlSeconds: number;
@@ -5793,6 +9268,32 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
 }, true, false, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.impersonate"> & {
     readonly name: "impersonate";
     readonly executable: true;
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    iss: string;
+    sub: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        iss: string;
+        sub: string;
+        frozen: boolean;
+        requiredClaims: ({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[];
+    } | null;
+}, true, false, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+    readonly name: "whois";
+    readonly executable: true;
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
     target: string;
 }, {
@@ -5835,32 +9336,6 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
 }, true, false, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.View.method.resolve"> & {
     readonly name: "resolve";
     readonly executable: true;
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
-    iss: string;
-    sub: string;
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        id: string;
-        iss: string;
-        sub: string;
-        frozen: boolean;
-        requiredClaims: ({
-            claim: string;
-            op: "contains";
-            value: unknown;
-        } | {
-            claim: string;
-            op: "eq";
-            value: unknown;
-        } | {
-            claim: string;
-            op: "exists";
-        })[];
-    } | null;
-}, true, false, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
-    readonly name: "whois";
-    readonly executable: true;
 }))[];
 export { AuthorityOperationOrder, AuthorityOperations, operationOf } from '../authority/index.js';
 export type { AuthorityOperation, AuthorityRelation } from '../authority/index.js';