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

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

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

Files changed (52) hide show

package/dist/schema/callables/function.d.ts CHANGED Viewed

@@ -16,7 +16,2504 @@ export declare const Function: builder.NodeClass<{
             readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
         };
         readonly methods: Readonly<Record<never, never>>;
-    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never>, never, never>];
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never>, never, never>, builder.ClassReferenceProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>>>];
     readonly properties: {
         readonly kind: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "kind", "self", undefined>;
         readonly input: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "input", "self", undefined>;
@@ -46,14 +2543,944 @@ export declare const Function: builder.NodeClass<{
             };
         }, "authenticated", true, false>>;
     }>;
-    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
         readonly abstract: true;
         readonly depth: 1;
         readonly properties: {
             readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
         };
         readonly methods: Readonly<Record<never, never>>;
-    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "abstract", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "auth", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "input", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "kind", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "output", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "policy", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "static", "self", never>);
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            } | {
+                checks: {
+                    policy: string;
+                    object: string;
+                }[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                } | {
+                    decisions: {
+                        allowed: boolean;
+                    }[];
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false>>, "whois", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false>>, "can", unknown>>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "abstract", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "auth", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "input", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "kind", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "output", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "policy", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "static", "self", never>);
     readonly abstractInstanceMethods: never;
     readonly abstractStaticMethods: never;
     readonly effectiveInstanceMethods: never;