@astrale-os/kernel-core 0.9.0-beta.5 → 0.9.0-beta.51

package/dist/schema/domain/domain.d.ts

@@ -1,156 +1,3175 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Domain: builder.NodeClass<{
-    readonly description: "A stable Domain principal and the active projection of one canonical DomainSchema revision.";
-    readonly implements: readonly [builder.NodeInterface<{
-        readonly description: "A principal that can be authenticated and can originate persistent authority facts.";
+    readonly depth: 2;
+    readonly abstract: false;
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
         readonly properties: {
-            readonly frozen: builder.Property<{
-                readonly type: "boolean";
-            }, {
-                readonly required: false;
-                readonly visibility: "private";
-            }>;
-            readonly iss: {
-                readonly type: "string";
-                readonly minLength: 1;
-            };
-            readonly requiredClaims: builder.Property<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                claim: import("zod").ZodString;
-                op: import("zod").ZodLiteral<"contains">;
-                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                claim: import("zod").ZodString;
-                op: import("zod").ZodLiteral<"eq">;
-                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                claim: import("zod").ZodString;
-                op: import("zod").ZodLiteral<"exists">;
-            }, import("zod/v4/core").$strict>], "op">>, {
-                readonly required: false;
-                readonly visibility: "private";
-            }>;
-            readonly sub: {
-                readonly type: "string";
-                readonly minLength: 1;
-            };
+            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.Function<{
-                readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
-                readonly auth: "authenticated";
-                readonly input: import("zod").ZodObject<{
-                    audience: import("zod").ZodString;
-                    ttlSeconds: import("zod").ZodNumber;
-                    attenuation: import("zod").ZodUnknown;
-                }, import("zod/v4/core").$strict>;
-                readonly output: import("zod").ZodString;
-                readonly inheritance: "default";
-            }>;
-            can: builder.Function<{
-                readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
-                readonly auth: "authenticated";
-                readonly input: import("zod").ZodObject<{
-                    policy: import("zod").ZodString;
-                    object: import("zod").ZodString;
-                }, import("zod/v4/core").$strict>;
-                readonly output: import("zod").ZodObject<{
-                    allowed: import("zod").ZodBoolean;
-                }, import("zod/v4/core").$strict>;
-                readonly static: true;
-                readonly inheritance: "default";
-            }>;
-            whoami: builder.Function<{
-                readonly description: "Return the Identity authenticated for this invocation.";
-                readonly auth: "authenticated";
-                readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
-                readonly output: import("zod").ZodObject<{
-                    id: import("zod").ZodString;
-                    issuer: import("zod").ZodString;
-                    subject: import("zod").ZodString;
-                    frozen: import("zod").ZodBoolean;
-                    requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"contains">;
-                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"eq">;
-                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"exists">;
-                    }, import("zod/v4/core").$strict>], "op">>;
-                }, import("zod/v4/core").$strict>;
-                readonly static: true;
-                readonly inheritance: "default";
-            }>;
-            whois: builder.Function<{
-                readonly description: "Resolve one issuer-and-subject Identity.";
-                readonly auth: "authorized";
-                readonly input: import("zod").ZodObject<{
-                    issuer: import("zod").ZodString;
-                    subject: import("zod").ZodString;
-                }, import("zod/v4/core").$strict>;
-                readonly output: import("zod").ZodNullable<import("zod").ZodObject<{
-                    id: import("zod").ZodString;
-                    issuer: import("zod").ZodString;
-                    subject: import("zod").ZodString;
-                    frozen: import("zod").ZodBoolean;
-                    requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"contains">;
-                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"eq">;
-                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"exists">;
-                    }, import("zod/v4/core").$strict>], "op">>;
-                }, import("zod/v4/core").$strict>>;
-                readonly static: true;
-                readonly inheritance: "default";
-            }>;
-            mint: builder.Function<{
-                readonly description: "Resolve and sign one authorized Grant credential.";
-                readonly auth: "authorized";
-                readonly input: import("zod").ZodObject<{
-                    audience: import("zod").ZodOptional<import("zod").ZodString>;
-                    ttlSeconds: import("zod").ZodNumber;
-                    grant: import("zod").ZodOptional<import("zod").ZodUnknown>;
-                }, import("zod/v4/core").$strict>;
-                readonly output: import("zod").ZodString;
-                readonly static: true;
-                readonly inheritance: "default";
-            }>;
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
         }>;
-    }>];
-    readonly properties: {
-        readonly origin: {
-            readonly type: "string";
-            readonly pattern: "[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+";
-        };
-        readonly dependencyContext: builder.Property<{
-            readonly type: "array";
-            readonly items: {
-                readonly type: "object";
-            };
-        }, {
-            readonly visibility: "private";
-            readonly required: 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;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "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;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "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;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>, never>, 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;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
         }>;
-        readonly schema: builder.Property<{
-            readonly type: "object";
-        }, {
-            readonly visibility: "private";
+    }, 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<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
         }>;
-        readonly schemaRevision: builder.Property<{
-            readonly type: "string";
-            readonly pattern: "sha256:[0-9a-f]{64}";
-        }, {
-            readonly visibility: "private";
+    }, 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<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
         }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>>>];
+    readonly properties: {
+        readonly origin: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "origin", "self", undefined>;
+        readonly dependencyContext: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "dependencyContext", "self", never>;
+        readonly schema: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schema", "self", never>;
+        readonly schemaRevision: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schemaRevision", "self", never>;
     };
+    readonly methods: Readonly<Record<never, never>>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "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;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "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;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", builder.ClassOwnerProjection<"node", {
+        readonly abstract: true;
+        readonly depth: 1;
+        readonly properties: {
+            readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+            readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+            readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+            readonly requiredClaims: builder.AuthoredPropertyProjection<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false, "requiredClaims", "self", never>;
+        };
+        readonly methods: Readonly<{
+            delegate: builder.Method<builder.CallableProjection<{
+                principal: string;
+                audience: string;
+                ttlSeconds: number;
+                attenuation: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            can: builder.Method<builder.CallableProjection<{
+                policy: string;
+                object: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, "authenticated", true, false>>;
+            whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, "authenticated", true, false>>;
+            whois: builder.Method<builder.CallableProjection<{
+                iss: string;
+                sub: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    iss: string;
+                    sub: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, "authorized", true, false>>;
+            mint: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authenticated", true, false>>;
+            impersonate: builder.Method<builder.CallableProjection<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+                identity: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, "authorized", true, false>>;
+        }>;
+    }, builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", unknown, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", unknown, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false>>, "whoami", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        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;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            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", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "mint", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        grant?: unknown;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false>>, "impersonate", unknown>>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "dependencyContext", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "origin", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schema", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schemaRevision", "self", never>);
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: never;
 }>;
-//# sourceMappingURL=domain.d.ts.map