npm - @astrale-os/kernel-core - Versions diffs - 0.9.0-beta.44 → 0.9.0-beta.46 - Mend

@astrale-os/kernel-core 0.9.0-beta.44 → 0.9.0-beta.46

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 (22) hide show

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

@@ -164,6 +164,15 @@ declare const KernelDefinitions: {
                     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>>;
             }>;
             readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never> | builder.AuthoredPropertyProjection<({
                 claim: string;
@@ -212,14 +221,6 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                principal: string;
-                audience: string;
-                ttlSeconds: number;
-                attenuation: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, "authenticated", true, false>>, "delegate", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 iss: string;
                 sub: string;
             }, {
@@ -243,6 +244,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | null;
             }, "authorized", true, false>>, "whois", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>, "delegate", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
                 policy: string;
                 object: string;
             }, {
@@ -257,7 +266,15 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", "self">;
+            }, "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">;
         }>;
         readonly Named: builder.NodeClass<{
             readonly depth: 1;
@@ -513,6 +530,15 @@ declare const KernelDefinitions: {
                         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;
@@ -639,6 +665,15 @@ declare const KernelDefinitions: {
                         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;
@@ -683,14 +718,6 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", 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<{
                 iss: string;
                 sub: string;
             }, {
@@ -714,6 +741,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | 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;
             }, {
@@ -728,7 +763,15 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", builder.ClassOwnerProjection<"node", {
+            }, "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>>, 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: {
@@ -831,6 +874,15 @@ declare const KernelDefinitions: {
                         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;
@@ -875,14 +927,6 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", 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<{
                 iss: string;
                 sub: string;
             }, {
@@ -906,6 +950,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | 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;
             }, {
@@ -920,7 +972,15 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", builder.ClassOwnerProjection<"node", {
+            }, "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>>, 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: {
@@ -1023,6 +1083,15 @@ declare const KernelDefinitions: {
                         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;
@@ -1067,14 +1136,6 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", 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<{
                 iss: string;
                 sub: string;
             }, {
@@ -1098,6 +1159,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | 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;
             }, {
@@ -1112,7 +1181,15 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", builder.ClassOwnerProjection<"node", {
+            }, "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>>, 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: {
@@ -1215,6 +1292,15 @@ declare const KernelDefinitions: {
                         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;
@@ -1259,14 +1345,6 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", 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<{
                 iss: string;
                 sub: string;
             }, {
@@ -1290,6 +1368,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | 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;
             }, {
@@ -1304,7 +1390,15 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown>>, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+            }, "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>>, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
                 readonly mode: 'value';
                 readonly value: {
                     id: string;
@@ -1427,6 +1521,15 @@ declare const KernelDefinitions: {
                         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;
@@ -1471,14 +1574,6 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", 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<{
                 iss: string;
                 sub: string;
             }, {
@@ -1502,6 +1597,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | 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;
             }, {
@@ -1516,15 +1619,38 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                principal: string;
-                audience: string;
+            }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
                 ttlSeconds: number;
-                attenuation: unknown;
+                grant?: unknown;
+                identity: string;
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "delegate", builder.ClassOwnerProjection<"node", {
+            }, "authorized", true, false>>, "impersonate", 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: {
@@ -1627,6 +1753,15 @@ declare const KernelDefinitions: {
                         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;
@@ -1671,14 +1806,6 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", 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<{
                 iss: string;
                 sub: string;
             }, {
@@ -1702,6 +1829,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | 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;
             }, {
@@ -1716,37 +1851,30 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-                iss: string;
-                sub: 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: {
-                    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<({
+                readonly value: string;
+            }, "authorized", true, false>>, "impersonate", 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;
@@ -1842,6 +1970,15 @@ declare const KernelDefinitions: {
                         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;
@@ -1886,14 +2023,6 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", 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<{
                 iss: string;
                 sub: string;
             }, {
@@ -1917,6 +2046,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | 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;
             }, {
@@ -1931,7 +2068,15 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+            }, "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;
             }, {
@@ -2042,6 +2187,15 @@ declare const KernelDefinitions: {
                         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;
@@ -2086,14 +2240,6 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", 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<{
                 iss: string;
                 sub: string;
             }, {
@@ -2117,6 +2263,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | 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;
             }, {
@@ -2131,7 +2285,15 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+            }, "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<{
                 audience?: string | undefined;
                 ttlSeconds: number;
                 grant?: unknown;
@@ -2241,6 +2403,15 @@ declare const KernelDefinitions: {
                         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;
@@ -2285,14 +2456,6 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", 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<{
                 iss: string;
                 sub: string;
             }, {
@@ -2316,6 +2479,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | 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;
             }, {
@@ -2330,37 +2501,23 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown>>>>];
-            readonly properties: {
-                readonly origin: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "origin", "self", undefined>;
-                readonly dependencyContext: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "dependencyContext", "self", never>;
-                readonly schema: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schema", "self", never>;
-                readonly schemaRevision: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schemaRevision", "self", never>;
-            };
-            readonly methods: Readonly<Record<never, never>>;
-            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", {
+            }, "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<{
+                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: {
@@ -2463,6 +2620,15 @@ declare const KernelDefinitions: {
                         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;
@@ -2507,14 +2673,6 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", 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<{
                 iss: string;
                 sub: string;
             }, {
@@ -2538,6 +2696,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | 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;
             }, {
@@ -2552,7 +2718,45 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", builder.ClassOwnerProjection<"node", {
+            }, "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>>>>];
+            readonly properties: {
+                readonly origin: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "origin", "self", undefined>;
+                readonly dependencyContext: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "dependencyContext", "self", never>;
+                readonly schema: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schema", "self", never>;
+                readonly schemaRevision: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schemaRevision", "self", never>;
+            };
+            readonly methods: Readonly<Record<never, never>>;
+            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: {
@@ -2655,6 +2859,15 @@ declare const KernelDefinitions: {
                         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;
@@ -2699,14 +2912,6 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", 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<{
                 iss: string;
                 sub: string;
             }, {
@@ -2730,6 +2935,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | 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;
             }, {
@@ -2744,7 +2957,15 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", builder.ClassOwnerProjection<"node", {
+            }, "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>>, 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: {
@@ -2847,6 +3068,15 @@ declare const KernelDefinitions: {
                         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;
@@ -2891,14 +3121,6 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", 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<{
                 iss: string;
                 sub: string;
             }, {
@@ -2922,6 +3144,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | 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;
             }, {
@@ -2936,11 +3166,19 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", 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>;
+            }, "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>>, 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<({
@@ -3039,6 +3277,15 @@ declare const KernelDefinitions: {
                         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;
@@ -3083,6 +3330,29 @@ declare const KernelDefinitions: {
                     })[];
                 };
             }, "authenticated", true, false>>, "whoami", 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;
@@ -3091,6 +3361,184 @@ declare const KernelDefinitions: {
                 readonly mode: 'value';
                 readonly value: string;
             }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    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", 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>>, 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;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            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<{
                 iss: string;
                 sub: string;
             }, {
@@ -3114,6 +3562,14 @@ declare const KernelDefinitions: {
                     })[];
                 } | 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;
             }, {
@@ -3128,7 +3584,15 @@ declare const KernelDefinitions: {
             }, {
                 readonly mode: 'value';
                 readonly value: string;
-            }, "authenticated", true, false>>, "mint", 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>);
+            }, "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>>, 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;
@@ -3957,6 +4421,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;
@@ -3985,30 +4472,7 @@ 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";
+                    op: "edge.delete";
                     edge: {
                         source: string;
                         target: string;
@@ -4431,6 +4895,31 @@ 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<{
+    operation: string;
+    domains: ({
+        artifact: {
+            digest: string;
+            mediaType: string;
+            size: number;
+        };
+        currentRevision?: string | null | undefined;
+    } | {
+        publication: {
+            url: string;
+            token?: string | undefined;
+            etag?: string | undefined;
+        };
+        revision?: string | undefined;
+        currentRevision?: string | null | undefined;
+    })[];
+}, {
+    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<"install"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.install";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     invocation?: {
         source: string;
         id: string;
@@ -4462,93 +4951,296 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
         readonly origin: "kernel.astrale.ai";
     };
     readonly key: "kernel.astrale.ai:function.journal";
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    idempotencyKey: string;
-    identities: ({
-        id: string;
-        mode: "external";
-        credential: string;
-    } | {
-        id: string;
-        mode: "self";
-        publicKey: unknown;
-        credential: string;
-    })[];
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        identities: {
-            id: string;
-            iss: string;
-            sub: 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<"register"> & {
-        readonly origin: "kernel.astrale.ai";
-    };
-    readonly key: "kernel.astrale.ai:function.register";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     ast: {
-        format: "astrale.graph.query";
-        version: "v6";
-        source: {
+        format: "astrale.graph.mutation";
+        version: "v3";
+        preconditions: ({
             kind: "node";
-            terms: ({
-                kind: "path";
-                path: string;
+            node: string;
+            class: string;
+            props?: {
+                equals: Record<string, unknown>;
+                absent?: string[] | undefined;
             } | {
-                kind: "class";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            })[];
-            binding: string;
+                absent: string[];
+            } | undefined;
         } | {
             kind: "edge";
-            terms: {
-                kind: "class";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            }[];
-            bindings: {
+            edge: {
                 source: string;
-                edge: string;
                 target: string;
+                class: string;
             };
-        };
-        steps: ({
-            op: "filter";
-            binding: string;
-            predicate: {
-                kind: "class.satisfies";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
+            slug?: unknown;
+            props?: {
+                equals: Record<string, unknown>;
+                absent?: string[] | undefined;
             } | {
-                kind: "class.equal";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
+                absent: string[];
+            } | undefined;
+        } | {
+            kind: "query";
+            query: {
+                format: "astrale.graph.query";
+                version: "v6";
+                source: {
+                    kind: "node";
+                    terms: ({
+                        kind: "path";
+                        path: string;
+                    } | {
+                        kind: "class";
+                        class: {
+                            origin: string;
+                            kind: "class";
+                            name: string;
+                        };
+                    })[];
+                    binding: string;
+                } | {
+                    kind: "edge";
+                    terms: {
+                        kind: "class";
+                        class: {
+                            origin: string;
+                            kind: "class";
+                            name: string;
+                        };
+                    }[];
+                    bindings: {
+                        source: string;
+                        edge: string;
+                        target: string;
+                    };
                 };
+                steps: ({
+                    op: "filter";
+                    binding: string;
+                    predicate: {
+                        kind: "class.satisfies";
+                        class: {
+                            origin: string;
+                            kind: "class";
+                            name: string;
+                        };
+                    } | {
+                        kind: "class.equal";
+                        class: {
+                            origin: string;
+                            kind: "class";
+                            name: string;
+                        };
+                    } | {
+                        kind: "property.equal";
+                        property: string;
+                        value: unknown;
+                    } | {
+                        kind: "property.present";
+                        property: string;
+                    } | {
+                        kind: "identity.equal";
+                        identity: string | {
+                            source: string;
+                            target: string;
+                            class: string;
+                        };
+                    };
+                } | {
+                    op: "expand";
+                    from: string;
+                    via: {
+                        origin: string;
+                        kind: "class";
+                        name: string;
+                    }[];
+                    direction: "incident" | "incoming" | "outgoing";
+                    bindings: {
+                        edge: string;
+                        node: string;
+                    };
+                })[];
+                select: {
+                    kind: "graph";
+                    binding: string;
+                    order?: {
+                        property: string;
+                        direction: "asc" | "desc";
+                        unranked: "first" | "last";
+                    } | undefined;
+                } | {
+                    kind: "nodes";
+                    binding: string;
+                    projection: {
+                        kind: "reference" | "value";
+                    };
+                    order?: {
+                        property: string;
+                        direction: "asc" | "desc";
+                        unranked: "first" | "last";
+                    } | undefined;
+                } | {
+                    kind: "edges";
+                    binding: string;
+                    projection: {
+                        edge: "reference" | "value";
+                        source: "reference" | "value";
+                        target: "reference" | "value";
+                    };
+                    order?: {
+                        property: string;
+                        direction: "asc" | "desc";
+                        unranked: "first" | "last";
+                    } | undefined;
+                };
+            };
+            equals: {
+                kind: "node";
+                ids: string[];
             } | {
-                kind: "property.equal";
-                property: string;
-                value: unknown;
-            } | {
-                kind: "property.present";
-                property: string;
-            } | {
-                kind: "identity.equal";
-                identity: string | {
+                kind: "edge";
+                keys: {
+                    source: string;
+                    target: string;
+                    class: string;
+                }[];
+            };
+        })[];
+        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;
+            props: Record<string, unknown>;
+        } | {
+            op: "node.update";
+            node: string;
+            class: string;
+            props: {
+                set: Record<string, unknown>;
+                unset: string[];
+            };
+        } | {
+            op: "node.delete";
+            node: string;
+            class: string;
+        } | {
+            op: "edge.create";
+            class: string;
+            source: string | {
+                created: string;
+            };
+            target: string | {
+                created: string;
+            };
+            slug?: unknown;
+            props: Record<string, unknown>;
+        } | {
+            op: "edge.delete";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
+            };
+        })[];
+    };
+    expected?: {
+        origin: string;
+        revision: string;
+    }[] | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        createdNodes: Record<string, 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<"mutate"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.mutate";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
+    ast: {
+        format: "astrale.graph.query";
+        version: "v6";
+        source: {
+            kind: "node";
+            terms: ({
+                kind: "path";
+                path: string;
+            } | {
+                kind: "class";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            })[];
+            binding: string;
+        } | {
+            kind: "edge";
+            terms: {
+                kind: "class";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            }[];
+            bindings: {
+                source: string;
+                edge: string;
+                target: string;
+            };
+        };
+        steps: ({
+            op: "filter";
+            binding: string;
+            predicate: {
+                kind: "class.satisfies";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            } | {
+                kind: "class.equal";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            } | {
+                kind: "property.equal";
+                property: string;
+                value: unknown;
+            } | {
+                kind: "property.present";
+                property: string;
+            } | {
+                kind: "identity.equal";
+                identity: string | {
                     source: string;
                     target: string;
                     class: string;
@@ -4716,259 +5408,31 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     };
     readonly key: "kernel.astrale.ai:function.query";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    ast: {
-        format: "astrale.graph.mutation";
-        version: "v3";
-        preconditions: ({
-            kind: "node";
-            node: string;
-            class: string;
-            props?: {
-                equals: Record<string, unknown>;
-                absent?: string[] | undefined;
-            } | {
-                absent: string[];
-            } | undefined;
-        } | {
-            kind: "edge";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
-            };
-            slug?: unknown;
-            props?: {
-                equals: Record<string, unknown>;
-                absent?: string[] | undefined;
-            } | {
-                absent: string[];
-            } | undefined;
-        } | {
-            kind: "query";
-            query: {
-                format: "astrale.graph.query";
-                version: "v6";
-                source: {
-                    kind: "node";
-                    terms: ({
-                        kind: "path";
-                        path: string;
-                    } | {
-                        kind: "class";
-                        class: {
-                            origin: string;
-                            kind: "class";
-                            name: string;
-                        };
-                    })[];
-                    binding: string;
-                } | {
-                    kind: "edge";
-                    terms: {
-                        kind: "class";
-                        class: {
-                            origin: string;
-                            kind: "class";
-                            name: string;
-                        };
-                    }[];
-                    bindings: {
-                        source: string;
-                        edge: string;
-                        target: string;
-                    };
-                };
-                steps: ({
-                    op: "filter";
-                    binding: string;
-                    predicate: {
-                        kind: "class.satisfies";
-                        class: {
-                            origin: string;
-                            kind: "class";
-                            name: string;
-                        };
-                    } | {
-                        kind: "class.equal";
-                        class: {
-                            origin: string;
-                            kind: "class";
-                            name: string;
-                        };
-                    } | {
-                        kind: "property.equal";
-                        property: string;
-                        value: unknown;
-                    } | {
-                        kind: "property.present";
-                        property: string;
-                    } | {
-                        kind: "identity.equal";
-                        identity: string | {
-                            source: string;
-                            target: string;
-                            class: string;
-                        };
-                    };
-                } | {
-                    op: "expand";
-                    from: string;
-                    via: {
-                        origin: string;
-                        kind: "class";
-                        name: string;
-                    }[];
-                    direction: "incident" | "incoming" | "outgoing";
-                    bindings: {
-                        edge: string;
-                        node: string;
-                    };
-                })[];
-                select: {
-                    kind: "graph";
-                    binding: string;
-                    order?: {
-                        property: string;
-                        direction: "asc" | "desc";
-                        unranked: "first" | "last";
-                    } | undefined;
-                } | {
-                    kind: "nodes";
-                    binding: string;
-                    projection: {
-                        kind: "reference" | "value";
-                    };
-                    order?: {
-                        property: string;
-                        direction: "asc" | "desc";
-                        unranked: "first" | "last";
-                    } | undefined;
-                } | {
-                    kind: "edges";
-                    binding: string;
-                    projection: {
-                        edge: "reference" | "value";
-                        source: "reference" | "value";
-                        target: "reference" | "value";
-                    };
-                    order?: {
-                        property: string;
-                        direction: "asc" | "desc";
-                        unranked: "first" | "last";
-                    } | undefined;
-                };
-            };
-            equals: {
-                kind: "node";
-                ids: string[];
-            } | {
-                kind: "edge";
-                keys: {
-                    source: string;
-                    target: string;
-                    class: string;
-                }[];
-            };
-        })[];
-        operations: ({
-            op: "node.create";
-            as: string;
-            class: string;
-            props: Record<string, unknown>;
-        } | {
-            op: "node.update";
-            node: string;
-            class: string;
-            props: {
-                set: Record<string, unknown>;
-                unset: string[];
-            };
-        } | {
-            op: "node.delete";
-            node: string;
-            class: string;
-        } | {
-            op: "edge.create";
-            class: string;
-            source: string | {
-                created: string;
-            };
-            target: string | {
-                created: string;
-            };
-            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: {
-                source: string;
-                target: string;
-                class: string;
-            };
-        })[];
-    };
-    expected?: {
-        origin: string;
-        revision: string;
-    }[] | undefined;
+    idempotencyKey: string;
+    identities: ({
+        id: string;
+        mode: "external";
+        credential: string;
+    } | {
+        id: string;
+        mode: "self";
+        publicKey: unknown;
+        credential: string;
+    })[];
 }, {
     readonly mode: 'value';
     readonly value: {
-        createdNodes: Record<string, string>;
+        identities: {
+            id: string;
+            iss: string;
+            sub: 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<"mutate"> & {
-        readonly origin: "kernel.astrale.ai";
-    };
-    readonly key: "kernel.astrale.ai:function.mutate";
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    operation: string;
-    domains: ({
-        artifact: {
-            digest: string;
-            mediaType: string;
-            size: number;
-        };
-        currentRevision?: string | null | undefined;
-    } | {
-        publication: {
-            url: string;
-            token?: string | undefined;
-            etag?: string | undefined;
-        };
-        revision?: string | undefined;
-        currentRevision?: string | null | undefined;
-    })[];
-}, {
-    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<"install"> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"register"> & {
         readonly origin: "kernel.astrale.ai";
     };
-    readonly key: "kernel.astrale.ai:function.install";
+    readonly key: "kernel.astrale.ai:function.register";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     operation: string;
     domains: string[];
@@ -5039,6 +5503,7 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     } | 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;
 }, {
@@ -5073,6 +5538,18 @@ 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<{
+    audience?: string | undefined;
+    ttlSeconds: number;
+    grant?: unknown;
+    identity: string;
+}, {
+    readonly mode: 'value';
+    readonly value: string;
+}, 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;
 }))[];
 export { AuthorityOperationOrder, AuthorityOperations, operationOf } from '../authority/index.js';
 export type { AuthorityOperation, AuthorityRelation } from '../authority/index.js';