@astrale-domains/shell 0.1.0-beta.4 → 0.1.0-beta.8

package/dist/schema/group/relationships.d.ts

@@ -1,259 +1,3274 @@
 export declare const member_of_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
-    readonly as: "user";
-    readonly accepts: readonly [import("@astrale-os/sdk/schema").NodeInterface<{
-        readonly description: "A human-facing Shell principal.";
-        readonly extends: readonly [{
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: "Identity";
-        }];
-    }>];
-    readonly outgoing: "0..*";
-}, {
-    readonly as: "group";
-    readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
-        readonly description: "A named compositional Shell Identity.";
-        readonly implements: readonly [{
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: string;
-        }, {
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: string;
-        }, {
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: string;
-        }];
-        readonly methods: {
-            assignUser: import("@astrale-os/sdk/schema").Function<{
-                readonly description: string;
-                readonly input: import("zod").ZodObject<{
-                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
-                        readonly description: "A human-facing Shell principal.";
-                        readonly extends: readonly [{
-                            origin: "kernel.astrale.ai";
-                            kind: 'interface';
-                            name: "Identity";
-                        }];
-                    }>]>;
-                }, import("zod/v4/core").$strict>;
-                readonly output: {
-                    type: 'object';
-                    properties: {};
-                    additionalProperties: boolean;
-                };
-                readonly auth: "authorized";
-                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-            }>;
-            unassignUser: import("@astrale-os/sdk/schema").Function<{
-                readonly description: string;
-                readonly input: import("zod").ZodObject<{
-                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
-                        readonly description: "A human-facing Shell principal.";
-                        readonly extends: readonly [{
-                            origin: "kernel.astrale.ai";
-                            kind: 'interface';
-                            name: "Identity";
-                        }];
-                    }>]>;
-                }, import("zod/v4/core").$strict>;
-                readonly output: {
-                    type: 'object';
-                    properties: {};
-                    additionalProperties: boolean;
-                };
-                readonly auth: "authorized";
-                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-            }>;
-        };
-    }>];
-    readonly incoming: "0..*";
-}, Omit<{
     readonly source: {
         readonly as: "user";
-        readonly accepts: readonly [import("@astrale-os/sdk/schema").NodeInterface<{
-            readonly description: "A human-facing Shell principal.";
-            readonly extends: readonly [{
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: "Identity";
-            }];
-        }>];
-        readonly outgoing: "0..*";
-    };
-    readonly target: {
-        readonly as: "group";
-        readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
-            readonly description: "A named compositional Shell Identity.";
-            readonly implements: readonly [{
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
+        readonly accepts: readonly [import("@astrale-os/sdk/schema").NodeClass<{
+            readonly description: "One externally identified person using Shell.";
+            readonly extends: readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
+                frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                    readonly name: "frozen";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                };
+                iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                    readonly name: "iss";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                };
+                requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
+                    claim: string;
+                    op: "contains";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "eq";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "exists";
+                })[], false> & {
+                    readonly name: "requiredClaims";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                };
+                sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                    readonly name: "sub";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                };
+            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                readonly name: "frozen";
+                readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                readonly name: "iss";
+                readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false> & {
+                readonly name: "requiredClaims";
+                readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                readonly name: "sub";
+                readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+            })> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                        readonly name: "frozen";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "iss";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false> & {
+                        readonly name: "requiredClaims";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "sub";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                        readonly name: "frozen";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "iss";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false> & {
+                        readonly name: "requiredClaims";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "sub";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{
+                    readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[] | undefined;
+                    readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                } & {
+                    readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly requiredClaims?: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[] | undefined;
+                    readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                }>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{
+                delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    audience: string;
+                    ttlSeconds: number;
+                    attenuation: unknown;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: string;
+                }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                    readonly name: "delegate";
+                };
+            }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
+                audience: string;
+                ttlSeconds: number;
+                attenuation: unknown;
             }, {
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
+                readonly mode: 'value';
+                readonly value: string;
+            }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                readonly name: "delegate";
+            }> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                        readonly name: "delegate";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                        readonly name: "delegate";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{
+                can: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    policy: string;
+                    object: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        allowed: boolean;
+                    };
+                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                    readonly name: "can";
+                };
+                mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    audience?: string | undefined;
+                    ttlSeconds: number;
+                    grant?: unknown;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: string;
+                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                    readonly name: "mint";
+                };
+                whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        id: string;
+                        issuer: string;
+                        subject: string;
+                        frozen: boolean;
+                        requiredClaims: ({
+                            claim: string;
+                            op: "contains";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "eq";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "exists";
+                        })[];
+                    };
+                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                    readonly name: "whoami";
+                };
+                whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    issuer: string;
+                    subject: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        id: string;
+                        issuer: string;
+                        subject: string;
+                        frozen: boolean;
+                        requiredClaims: ({
+                            claim: string;
+                            op: "contains";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "eq";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "exists";
+                        })[];
+                    } | null;
+                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                    readonly name: "whois";
+                };
+            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
+                policy: string;
+                object: string;
             }, {
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
-            }];
-            readonly methods: {
-                assignUser: import("@astrale-os/sdk/schema").Function<{
-                    readonly description: string;
-                    readonly input: import("zod").ZodObject<{
-                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
-                            readonly description: "A human-facing Shell principal.";
-                            readonly extends: readonly [{
-                                origin: "kernel.astrale.ai";
-                                kind: 'interface';
-                                name: "Identity";
-                            }];
-                        }>]>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: {
-                        type: 'object';
-                        properties: {};
-                        additionalProperties: boolean;
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                readonly name: "can";
+            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                readonly name: "mint";
+            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    issuer: string;
+                    subject: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                readonly name: "whoami";
+            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                issuer: string;
+                subject: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    issuer: string;
+                    subject: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                readonly name: "whois";
+            })> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        policy: string;
+                        object: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                        readonly name: "can";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                        readonly name: "mint";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                        readonly name: "whoami";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        issuer: string;
+                        subject: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                        readonly name: "whois";
                     };
-                    readonly auth: "authorized";
-                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
                 }>;
-                unassignUser: import("@astrale-os/sdk/schema").Function<{
-                    readonly description: string;
-                    readonly input: import("zod").ZodObject<{
-                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
-                            readonly description: "A human-facing Shell principal.";
-                            readonly extends: readonly [{
-                                origin: "kernel.astrale.ai";
-                                kind: 'interface';
-                                name: "Identity";
-                            }];
-                        }>]>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: {
-                        type: 'object';
-                        properties: {};
-                        additionalProperties: boolean;
+                get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        policy: string;
+                        object: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                        readonly name: "can";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                        readonly name: "mint";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                        readonly name: "whoami";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        issuer: string;
+                        subject: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                        readonly name: "whois";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{
+                frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                    readonly name: "frozen";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                };
+                iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                    readonly name: "iss";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                };
+                requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
+                    claim: string;
+                    op: "contains";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "eq";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "exists";
+                })[], false> & {
+                    readonly name: "requiredClaims";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                };
+                sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                    readonly name: "sub";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                };
+            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                readonly name: "frozen";
+                readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                readonly name: "iss";
+                readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false> & {
+                readonly name: "requiredClaims";
+                readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                readonly name: "sub";
+                readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+            })> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                        readonly name: "frozen";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "iss";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false> & {
+                        readonly name: "requiredClaims";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "sub";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                        readonly name: "frozen";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "iss";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false> & {
+                        readonly name: "requiredClaims";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "sub";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{
+                    readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[] | undefined;
+                    readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                } & {
+                    readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly requiredClaims?: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[] | undefined;
+                    readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                }>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{
+                delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    audience: string;
+                    ttlSeconds: number;
+                    attenuation: unknown;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: string;
+                }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                    readonly name: "delegate";
+                };
+            }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
+                audience: string;
+                ttlSeconds: number;
+                attenuation: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                readonly name: "delegate";
+            }> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                        readonly name: "delegate";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                        readonly name: "delegate";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{
+                can: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    policy: string;
+                    object: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        allowed: boolean;
+                    };
+                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                    readonly name: "can";
+                };
+                mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    audience?: string | undefined;
+                    ttlSeconds: number;
+                    grant?: unknown;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: string;
+                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                    readonly name: "mint";
+                };
+                whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        id: string;
+                        issuer: string;
+                        subject: string;
+                        frozen: boolean;
+                        requiredClaims: ({
+                            claim: string;
+                            op: "contains";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "eq";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "exists";
+                        })[];
+                    };
+                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                    readonly name: "whoami";
+                };
+                whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    issuer: string;
+                    subject: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        id: string;
+                        issuer: string;
+                        subject: string;
+                        frozen: boolean;
+                        requiredClaims: ({
+                            claim: string;
+                            op: "contains";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "eq";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "exists";
+                        })[];
+                    } | null;
+                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                    readonly name: "whois";
+                };
+            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
+                policy: string;
+                object: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                readonly name: "can";
+            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                readonly name: "mint";
+            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    issuer: string;
+                    subject: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                readonly name: "whoami";
+            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                issuer: string;
+                subject: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    issuer: string;
+                    subject: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                readonly name: "whois";
+            })> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        policy: string;
+                        object: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                        readonly name: "can";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                        readonly name: "mint";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                        readonly name: "whoami";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        issuer: string;
+                        subject: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                        readonly name: "whois";
                     };
-                    readonly auth: "authorized";
-                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        policy: string;
+                        object: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                        readonly name: "can";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                        readonly name: "mint";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                        readonly name: "whoami";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        issuer: string;
+                        subject: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                        readonly name: "whois";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, readonly []> & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly key: "kernel.astrale.ai:class.Node";
+            }]> & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly key: "kernel.astrale.ai:class.Identity";
+            }];
+            readonly properties: {
+                displayName: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {
+                    readonly required: false;
+                }>;
+            };
+            readonly methods: {
+                readonly resolveHome: import("@astrale-os/sdk/schema").Method<{
+                    readonly description: "Resolve this User and its canonical personal Space.";
+                    readonly auth: "authenticated";
+                    readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+                    readonly output: import("zod").ZodObject<{
+                        userId: import("zod").ZodString;
+                        personalSpaceId: import("zod").ZodNullable<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strict>;
                 }>;
             };
         }>];
-        readonly incoming: "0..*";
-    };
-    readonly description: "Shell product membership.";
-}, "source" | "target">>;
-export declare const administers_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
-    readonly as: "admin";
-    readonly accepts: readonly [{
-        origin: "kernel.astrale.ai";
-        kind: 'interface';
-        name: "Identity";
-    }];
-    readonly outgoing: "0..*";
-}, {
-    readonly as: "group";
-    readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
-        readonly description: "A named compositional Shell Identity.";
-        readonly implements: readonly [{
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: string;
-        }, {
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: string;
-        }, {
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: string;
-        }];
-        readonly methods: {
-            assignUser: import("@astrale-os/sdk/schema").Function<{
-                readonly description: string;
-                readonly input: import("zod").ZodObject<{
-                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
-                        readonly description: "A human-facing Shell principal.";
-                        readonly extends: readonly [{
-                            origin: "kernel.astrale.ai";
-                            kind: 'interface';
-                            name: "Identity";
-                        }];
-                    }>]>;
-                }, import("zod/v4/core").$strict>;
-                readonly output: {
-                    type: 'object';
-                    properties: {};
-                    additionalProperties: boolean;
-                };
-                readonly auth: "authorized";
-                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-            }>;
-            unassignUser: import("@astrale-os/sdk/schema").Function<{
-                readonly description: string;
-                readonly input: import("zod").ZodObject<{
-                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
-                        readonly description: "A human-facing Shell principal.";
-                        readonly extends: readonly [{
-                            origin: "kernel.astrale.ai";
-                            kind: 'interface';
-                            name: "Identity";
-                        }];
-                    }>]>;
-                }, import("zod/v4/core").$strict>;
-                readonly output: {
-                    type: 'object';
-                    properties: {};
-                    additionalProperties: boolean;
-                };
-                readonly auth: "authorized";
-                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-            }>;
-        };
-    }>];
-    readonly incoming: "0..*";
-}, Omit<{
-    readonly source: {
-        readonly as: "admin";
-        readonly accepts: readonly [{
-            origin: "kernel.astrale.ai";
-            kind: 'interface';
-            name: "Identity";
-        }];
         readonly outgoing: "0..*";
     };
     readonly target: {
         readonly as: "group";
         readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
             readonly description: "A named compositional Shell Identity.";
-            readonly implements: readonly [{
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
+            readonly extends: readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
+                frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                    readonly name: "frozen";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                };
+                iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                    readonly name: "iss";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                };
+                requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
+                    claim: string;
+                    op: "contains";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "eq";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "exists";
+                })[], false> & {
+                    readonly name: "requiredClaims";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                };
+                sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                    readonly name: "sub";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                };
+            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                readonly name: "frozen";
+                readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                readonly name: "iss";
+                readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false> & {
+                readonly name: "requiredClaims";
+                readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                readonly name: "sub";
+                readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+            })> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                        readonly name: "frozen";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "iss";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false> & {
+                        readonly name: "requiredClaims";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "sub";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                        readonly name: "frozen";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "iss";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false> & {
+                        readonly name: "requiredClaims";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "sub";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{
+                    readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[] | undefined;
+                    readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                } & {
+                    readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly requiredClaims?: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[] | undefined;
+                    readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                }>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{
+                delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    audience: string;
+                    ttlSeconds: number;
+                    attenuation: unknown;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: string;
+                }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                    readonly name: "delegate";
+                };
+            }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
+                audience: string;
+                ttlSeconds: number;
+                attenuation: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                readonly name: "delegate";
+            }> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                        readonly name: "delegate";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                        readonly name: "delegate";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{
+                can: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    policy: string;
+                    object: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        allowed: boolean;
+                    };
+                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                    readonly name: "can";
+                };
+                mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    audience?: string | undefined;
+                    ttlSeconds: number;
+                    grant?: unknown;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: string;
+                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                    readonly name: "mint";
+                };
+                whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        id: string;
+                        issuer: string;
+                        subject: string;
+                        frozen: boolean;
+                        requiredClaims: ({
+                            claim: string;
+                            op: "contains";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "eq";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "exists";
+                        })[];
+                    };
+                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                    readonly name: "whoami";
+                };
+                whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    issuer: string;
+                    subject: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        id: string;
+                        issuer: string;
+                        subject: string;
+                        frozen: boolean;
+                        requiredClaims: ({
+                            claim: string;
+                            op: "contains";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "eq";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "exists";
+                        })[];
+                    } | null;
+                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                    readonly name: "whois";
+                };
+            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
+                policy: string;
+                object: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                readonly name: "can";
+            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                readonly name: "mint";
+            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    issuer: string;
+                    subject: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                readonly name: "whoami";
+            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                issuer: string;
+                subject: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    issuer: string;
+                    subject: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                readonly name: "whois";
+            })> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        policy: string;
+                        object: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                        readonly name: "can";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                        readonly name: "mint";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                        readonly name: "whoami";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        issuer: string;
+                        subject: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                        readonly name: "whois";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        policy: string;
+                        object: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                        readonly name: "can";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                        readonly name: "mint";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                        readonly name: "whoami";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        issuer: string;
+                        subject: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                        readonly name: "whois";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{
+                frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                    readonly name: "frozen";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                };
+                iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                    readonly name: "iss";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                };
+                requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
+                    claim: string;
+                    op: "contains";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "eq";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "exists";
+                })[], false> & {
+                    readonly name: "requiredClaims";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                };
+                sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                    readonly name: "sub";
+                    readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                };
+            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                readonly name: "frozen";
+                readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                readonly name: "iss";
+                readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[], false> & {
+                readonly name: "requiredClaims";
+                readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                readonly name: "sub";
+                readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+            })> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                        readonly name: "frozen";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "iss";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false> & {
+                        readonly name: "requiredClaims";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "sub";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                        readonly name: "frozen";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "iss";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[], false> & {
+                        readonly name: "requiredClaims";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                    };
+                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "sub";
+                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{
+                    readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[] | undefined;
+                    readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                } & {
+                    readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                    readonly requiredClaims?: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[] | undefined;
+                    readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                }>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{
+                delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    audience: string;
+                    ttlSeconds: number;
+                    attenuation: unknown;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: string;
+                }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                    readonly name: "delegate";
+                };
+            }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
+                audience: string;
+                ttlSeconds: number;
+                attenuation: unknown;
+            }, {
+                readonly mode: 'value';
+                readonly value: string;
+            }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                readonly name: "delegate";
+            }> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                        readonly name: "delegate";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience: string;
+                        ttlSeconds: number;
+                        attenuation: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                        readonly name: "delegate";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{
+                can: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    policy: string;
+                    object: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        allowed: boolean;
+                    };
+                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                    readonly name: "can";
+                };
+                mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    audience?: string | undefined;
+                    ttlSeconds: number;
+                    grant?: unknown;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: string;
+                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                    readonly name: "mint";
+                };
+                whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        id: string;
+                        issuer: string;
+                        subject: string;
+                        frozen: boolean;
+                        requiredClaims: ({
+                            claim: string;
+                            op: "contains";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "eq";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "exists";
+                        })[];
+                    };
+                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                    readonly name: "whoami";
+                };
+                whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                    issuer: string;
+                    subject: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        id: string;
+                        issuer: string;
+                        subject: string;
+                        frozen: boolean;
+                        requiredClaims: ({
+                            claim: string;
+                            op: "contains";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "eq";
+                            value: unknown;
+                        } | {
+                            claim: string;
+                            op: "exists";
+                        })[];
+                    } | null;
+                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                    readonly name: "whois";
+                };
+            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
+                policy: string;
+                object: string;
             }, {
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
+                readonly mode: 'value';
+                readonly value: {
+                    allowed: boolean;
+                };
+            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                readonly name: "can";
+            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                audience?: string | undefined;
+                ttlSeconds: number;
+                grant?: unknown;
             }, {
-                origin: "kernel.astrale.ai";
-                kind: 'interface';
-                name: string;
+                readonly mode: 'value';
+                readonly value: string;
+            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                readonly name: "mint";
+            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    issuer: string;
+                    subject: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                };
+            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                readonly name: "whoami";
+            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                issuer: string;
+                subject: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    id: string;
+                    issuer: string;
+                    subject: string;
+                    frozen: boolean;
+                    requiredClaims: ({
+                        claim: string;
+                        op: "contains";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "eq";
+                        value: unknown;
+                    } | {
+                        claim: string;
+                        op: "exists";
+                    })[];
+                } | null;
+            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                readonly name: "whois";
+            })> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        policy: string;
+                        object: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                        readonly name: "can";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                        readonly name: "mint";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                        readonly name: "whoami";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        issuer: string;
+                        subject: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                        readonly name: "whois";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        policy: string;
+                        object: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            allowed: boolean;
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                        readonly name: "can";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        audience?: string | undefined;
+                        ttlSeconds: number;
+                        grant?: unknown;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: string;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                        readonly name: "mint";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        };
+                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                        readonly name: "whoami";
+                    };
+                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                        issuer: string;
+                        subject: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            id: string;
+                            issuer: string;
+                            subject: string;
+                            frozen: boolean;
+                            requiredClaims: ({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[];
+                        } | null;
+                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                        readonly name: "whois";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, readonly []> & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly key: "kernel.astrale.ai:class.Node";
+            }]> & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly key: "kernel.astrale.ai:class.Identity";
+            }, import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
+                name: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                    readonly name: "name";
+                    readonly key: "kernel.astrale.ai:class.Named.property.name";
+                };
+            }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                readonly name: "name";
+                readonly key: "kernel.astrale.ai:class.Named.property.name";
+            }> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "name";
+                        readonly key: "kernel.astrale.ai:class.Named.property.name";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Named.property.name">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "name";
+                        readonly key: "kernel.astrale.ai:class.Named.property.name";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{
+                    readonly "kernel.astrale.ai:class.Named.property.name"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                } & {
+                    readonly name?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                }>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{
+                name: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                    readonly name: "name";
+                    readonly key: "kernel.astrale.ai:class.Named.property.name";
+                };
+            }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                readonly name: "name";
+                readonly key: "kernel.astrale.ai:class.Named.property.name";
+            }> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "name";
+                        readonly key: "kernel.astrale.ai:class.Named.property.name";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Named.property.name">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                        readonly name: "name";
+                        readonly key: "kernel.astrale.ai:class.Named.property.name";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{
+                    readonly "kernel.astrale.ai:class.Named.property.name"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                } & {
+                    readonly name?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                }>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, readonly []> & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly key: "kernel.astrale.ai:class.Node";
+            }]> & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly key: "kernel.astrale.ai:class.Named";
+            }, import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
+                description: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                    readonly name: "description";
+                    readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
+                };
+            }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                readonly name: "description";
+                readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
+            }> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                        readonly name: "description";
+                        readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Descriptable.property.description">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                        readonly name: "description";
+                        readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{
+                    readonly "kernel.astrale.ai:class.Descriptable.property.description"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                } & {
+                    readonly description?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                }>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{
+                description: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                    readonly name: "description";
+                    readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
+                };
+            }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                readonly name: "description";
+                readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
+            }> & {
+                readonly byKey: Readonly<{
+                    "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                        readonly name: "description";
+                        readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
+                    };
+                }>;
+                get<Key extends "kernel.astrale.ai:class.Descriptable.property.description">(key: Key): Readonly<{
+                    "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                        readonly name: "description";
+                        readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
+                    };
+                }>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{
+                    readonly "kernel.astrale.ai:class.Descriptable.property.description"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                } & {
+                    readonly description?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                }>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                readonly byKey: Readonly<{}>;
+                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+            }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, readonly []> & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly key: "kernel.astrale.ai:class.Node";
+            }]> & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly key: "kernel.astrale.ai:class.Descriptable";
             }];
             readonly methods: {
-                assignUser: import("@astrale-os/sdk/schema").Function<{
+                assignUser: import("@astrale-os/sdk/schema").Method<{
                     readonly description: string;
                     readonly input: import("zod").ZodObject<{
-                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
-                            readonly description: "A human-facing Shell principal.";
-                            readonly extends: readonly [{
-                                origin: "kernel.astrale.ai";
-                                kind: 'interface';
-                                name: "Identity";
+                        user: import("@astrale-os/sdk/schema").PathAuthoring<readonly [import("@astrale-os/sdk/schema").NodeClass<{
+                            readonly description: "One externally identified person using Shell.";
+                            readonly extends: readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
+                                frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                    readonly name: "frozen";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                                };
+                                iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                    readonly name: "iss";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                                };
+                                requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                    claim: string;
+                                    op: "contains";
+                                    value: unknown;
+                                } | {
+                                    claim: string;
+                                    op: "eq";
+                                    value: unknown;
+                                } | {
+                                    claim: string;
+                                    op: "exists";
+                                })[], false> & {
+                                    readonly name: "requiredClaims";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                                };
+                                sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                    readonly name: "sub";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                                };
+                            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                readonly name: "frozen";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                readonly name: "iss";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[], false> & {
+                                readonly name: "requiredClaims";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                readonly name: "sub";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                            })> & {
+                                readonly byKey: Readonly<{
+                                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                        readonly name: "frozen";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "iss";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[], false> & {
+                                        readonly name: "requiredClaims";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "sub";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                                    };
+                                }>;
+                                get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
+                                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                        readonly name: "frozen";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "iss";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[], false> & {
+                                        readonly name: "requiredClaims";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "sub";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                                    };
+                                }>[Key];
+                                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                                from(input: Readonly<{
+                                    readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[] | undefined;
+                                    readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                } & {
+                                    readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly requiredClaims?: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[] | undefined;
+                                    readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                }>): import("@astrale-os/sdk/schema").PropertyValues;
+                            }, Readonly<Readonly<{
+                                delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    audience: string;
+                                    ttlSeconds: number;
+                                    attenuation: unknown;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: string;
+                                }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                    readonly name: "delegate";
+                                };
+                            }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                audience: string;
+                                ttlSeconds: number;
+                                attenuation: unknown;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: string;
+                            }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                readonly name: "delegate";
+                            }> & {
+                                readonly byKey: Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience: string;
+                                        ttlSeconds: number;
+                                        attenuation: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                        readonly name: "delegate";
+                                    };
+                                }>;
+                                get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience: string;
+                                        ttlSeconds: number;
+                                        attenuation: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                        readonly name: "delegate";
+                                    };
+                                }>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, Readonly<Readonly<{
+                                can: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    policy: string;
+                                    object: string;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: {
+                                        allowed: boolean;
+                                    };
+                                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                    readonly name: "can";
+                                };
+                                mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    audience?: string | undefined;
+                                    ttlSeconds: number;
+                                    grant?: unknown;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: string;
+                                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                    readonly name: "mint";
+                                };
+                                whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                    readonly mode: 'value';
+                                    readonly value: {
+                                        id: string;
+                                        issuer: string;
+                                        subject: string;
+                                        frozen: boolean;
+                                        requiredClaims: ({
+                                            claim: string;
+                                            op: "contains";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "eq";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "exists";
+                                        })[];
+                                    };
+                                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                    readonly name: "whoami";
+                                };
+                                whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    issuer: string;
+                                    subject: string;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: {
+                                        id: string;
+                                        issuer: string;
+                                        subject: string;
+                                        frozen: boolean;
+                                        requiredClaims: ({
+                                            claim: string;
+                                            op: "contains";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "eq";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "exists";
+                                        })[];
+                                    } | null;
+                                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                    readonly name: "whois";
+                                };
+                            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                policy: string;
+                                object: string;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: {
+                                    allowed: boolean;
+                                };
+                            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                readonly name: "can";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                audience?: string | undefined;
+                                ttlSeconds: number;
+                                grant?: unknown;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: string;
+                            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                readonly name: "mint";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                readonly mode: 'value';
+                                readonly value: {
+                                    id: string;
+                                    issuer: string;
+                                    subject: string;
+                                    frozen: boolean;
+                                    requiredClaims: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[];
+                                };
+                            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                readonly name: "whoami";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                issuer: string;
+                                subject: string;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: {
+                                    id: string;
+                                    issuer: string;
+                                    subject: string;
+                                    frozen: boolean;
+                                    requiredClaims: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[];
+                                } | null;
+                            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                readonly name: "whois";
+                            })> & {
+                                readonly byKey: Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        policy: string;
+                                        object: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            allowed: boolean;
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                        readonly name: "can";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience?: string | undefined;
+                                        ttlSeconds: number;
+                                        grant?: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                        readonly name: "mint";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                        readonly name: "whoami";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        issuer: string;
+                                        subject: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        } | null;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                        readonly name: "whois";
+                                    };
+                                }>;
+                                get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        policy: string;
+                                        object: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            allowed: boolean;
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                        readonly name: "can";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience?: string | undefined;
+                                        ttlSeconds: number;
+                                        grant?: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                        readonly name: "mint";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                        readonly name: "whoami";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        issuer: string;
+                                        subject: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        } | null;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                        readonly name: "whois";
+                                    };
+                                }>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, Readonly<Readonly<{
+                                frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                    readonly name: "frozen";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                                };
+                                iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                    readonly name: "iss";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                                };
+                                requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                    claim: string;
+                                    op: "contains";
+                                    value: unknown;
+                                } | {
+                                    claim: string;
+                                    op: "eq";
+                                    value: unknown;
+                                } | {
+                                    claim: string;
+                                    op: "exists";
+                                })[], false> & {
+                                    readonly name: "requiredClaims";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                                };
+                                sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                    readonly name: "sub";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                                };
+                            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                readonly name: "frozen";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                readonly name: "iss";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[], false> & {
+                                readonly name: "requiredClaims";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                readonly name: "sub";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                            })> & {
+                                readonly byKey: Readonly<{
+                                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                        readonly name: "frozen";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "iss";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[], false> & {
+                                        readonly name: "requiredClaims";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "sub";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                                    };
+                                }>;
+                                get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
+                                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                        readonly name: "frozen";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "iss";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[], false> & {
+                                        readonly name: "requiredClaims";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "sub";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                                    };
+                                }>[Key];
+                                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                                from(input: Readonly<{
+                                    readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[] | undefined;
+                                    readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                } & {
+                                    readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly requiredClaims?: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[] | undefined;
+                                    readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                }>): import("@astrale-os/sdk/schema").PropertyValues;
+                            }, Readonly<Readonly<{
+                                delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    audience: string;
+                                    ttlSeconds: number;
+                                    attenuation: unknown;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: string;
+                                }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                    readonly name: "delegate";
+                                };
+                            }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                audience: string;
+                                ttlSeconds: number;
+                                attenuation: unknown;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: string;
+                            }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                readonly name: "delegate";
+                            }> & {
+                                readonly byKey: Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience: string;
+                                        ttlSeconds: number;
+                                        attenuation: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                        readonly name: "delegate";
+                                    };
+                                }>;
+                                get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience: string;
+                                        ttlSeconds: number;
+                                        attenuation: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                        readonly name: "delegate";
+                                    };
+                                }>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, Readonly<Readonly<{
+                                can: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    policy: string;
+                                    object: string;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: {
+                                        allowed: boolean;
+                                    };
+                                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                    readonly name: "can";
+                                };
+                                mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    audience?: string | undefined;
+                                    ttlSeconds: number;
+                                    grant?: unknown;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: string;
+                                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                    readonly name: "mint";
+                                };
+                                whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                    readonly mode: 'value';
+                                    readonly value: {
+                                        id: string;
+                                        issuer: string;
+                                        subject: string;
+                                        frozen: boolean;
+                                        requiredClaims: ({
+                                            claim: string;
+                                            op: "contains";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "eq";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "exists";
+                                        })[];
+                                    };
+                                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                    readonly name: "whoami";
+                                };
+                                whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    issuer: string;
+                                    subject: string;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: {
+                                        id: string;
+                                        issuer: string;
+                                        subject: string;
+                                        frozen: boolean;
+                                        requiredClaims: ({
+                                            claim: string;
+                                            op: "contains";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "eq";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "exists";
+                                        })[];
+                                    } | null;
+                                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                    readonly name: "whois";
+                                };
+                            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                policy: string;
+                                object: string;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: {
+                                    allowed: boolean;
+                                };
+                            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                readonly name: "can";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                audience?: string | undefined;
+                                ttlSeconds: number;
+                                grant?: unknown;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: string;
+                            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                readonly name: "mint";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                readonly mode: 'value';
+                                readonly value: {
+                                    id: string;
+                                    issuer: string;
+                                    subject: string;
+                                    frozen: boolean;
+                                    requiredClaims: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[];
+                                };
+                            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                readonly name: "whoami";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                issuer: string;
+                                subject: string;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: {
+                                    id: string;
+                                    issuer: string;
+                                    subject: string;
+                                    frozen: boolean;
+                                    requiredClaims: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[];
+                                } | null;
+                            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                readonly name: "whois";
+                            })> & {
+                                readonly byKey: Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        policy: string;
+                                        object: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            allowed: boolean;
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                        readonly name: "can";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience?: string | undefined;
+                                        ttlSeconds: number;
+                                        grant?: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                        readonly name: "mint";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                        readonly name: "whoami";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        issuer: string;
+                                        subject: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        } | null;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                        readonly name: "whois";
+                                    };
+                                }>;
+                                get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        policy: string;
+                                        object: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            allowed: boolean;
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                        readonly name: "can";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience?: string | undefined;
+                                        ttlSeconds: number;
+                                        grant?: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                        readonly name: "mint";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                        readonly name: "whoami";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        issuer: string;
+                                        subject: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        } | null;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                        readonly name: "whois";
+                                    };
+                                }>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
+                                    readonly origin: "kernel.astrale.ai";
+                                };
+                                readonly kind: 'node';
+                                readonly abstract: true;
+                            }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
+                                readonly byKey: Readonly<{}>;
+                                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                                from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
+                            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                                readonly byKey: Readonly<{}>;
+                                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                                readonly byKey: Readonly<{}>;
+                                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                                readonly byKey: Readonly<{}>;
+                                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                                from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
+                            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                                readonly byKey: Readonly<{}>;
+                                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                                readonly byKey: Readonly<{}>;
+                                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                                    readonly origin: "kernel.astrale.ai";
+                                };
+                                readonly kind: 'node';
+                                readonly abstract: true;
+                            }, readonly []> & {
+                                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                                    readonly origin: "kernel.astrale.ai";
+                                };
+                                readonly key: "kernel.astrale.ai:class.Node";
+                            }]> & {
+                                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
+                                    readonly origin: "kernel.astrale.ai";
+                                };
+                                readonly key: "kernel.astrale.ai:class.Identity";
                             }];
+                            readonly properties: {
+                                displayName: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {
+                                    readonly required: false;
+                                }>;
+                            };
+                            readonly methods: {
+                                readonly resolveHome: import("@astrale-os/sdk/schema").Method<{
+                                    readonly description: "Resolve this User and its canonical personal Space.";
+                                    readonly auth: "authenticated";
+                                    readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+                                    readonly output: import("zod").ZodObject<{
+                                        userId: import("zod").ZodString;
+                                        personalSpaceId: import("zod").ZodNullable<import("zod").ZodString>;
+                                    }, import("zod/v4/core").$strict>;
+                                }>;
+                            };
                         }>]>;
                     }, import("zod/v4/core").$strict>;
                     readonly output: {
@@ -262,18 +3277,1024 @@ export declare const administers_group: import("@astrale-os/sdk/schema").Directe
                         additionalProperties: boolean;
                     };
                     readonly auth: "authorized";
-                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                    readonly policy: ({ check, ref }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
                 }>;
-                unassignUser: import("@astrale-os/sdk/schema").Function<{
+                unassignUser: import("@astrale-os/sdk/schema").Method<{
                     readonly description: string;
                     readonly input: import("zod").ZodObject<{
-                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
-                            readonly description: "A human-facing Shell principal.";
-                            readonly extends: readonly [{
-                                origin: "kernel.astrale.ai";
-                                kind: 'interface';
-                                name: "Identity";
+                        user: import("@astrale-os/sdk/schema").PathAuthoring<readonly [import("@astrale-os/sdk/schema").NodeClass<{
+                            readonly description: "One externally identified person using Shell.";
+                            readonly extends: readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
+                                frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                    readonly name: "frozen";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                                };
+                                iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                    readonly name: "iss";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                                };
+                                requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                    claim: string;
+                                    op: "contains";
+                                    value: unknown;
+                                } | {
+                                    claim: string;
+                                    op: "eq";
+                                    value: unknown;
+                                } | {
+                                    claim: string;
+                                    op: "exists";
+                                })[], false> & {
+                                    readonly name: "requiredClaims";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                                };
+                                sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                    readonly name: "sub";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                                };
+                            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                readonly name: "frozen";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                readonly name: "iss";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[], false> & {
+                                readonly name: "requiredClaims";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                readonly name: "sub";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                            })> & {
+                                readonly byKey: Readonly<{
+                                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                        readonly name: "frozen";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "iss";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[], false> & {
+                                        readonly name: "requiredClaims";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "sub";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                                    };
+                                }>;
+                                get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
+                                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                        readonly name: "frozen";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "iss";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[], false> & {
+                                        readonly name: "requiredClaims";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "sub";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                                    };
+                                }>[Key];
+                                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                                from(input: Readonly<{
+                                    readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[] | undefined;
+                                    readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                } & {
+                                    readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly requiredClaims?: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[] | undefined;
+                                    readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                }>): import("@astrale-os/sdk/schema").PropertyValues;
+                            }, Readonly<Readonly<{
+                                delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    audience: string;
+                                    ttlSeconds: number;
+                                    attenuation: unknown;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: string;
+                                }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                    readonly name: "delegate";
+                                };
+                            }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                audience: string;
+                                ttlSeconds: number;
+                                attenuation: unknown;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: string;
+                            }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                readonly name: "delegate";
+                            }> & {
+                                readonly byKey: Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience: string;
+                                        ttlSeconds: number;
+                                        attenuation: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                        readonly name: "delegate";
+                                    };
+                                }>;
+                                get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience: string;
+                                        ttlSeconds: number;
+                                        attenuation: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                        readonly name: "delegate";
+                                    };
+                                }>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, Readonly<Readonly<{
+                                can: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    policy: string;
+                                    object: string;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: {
+                                        allowed: boolean;
+                                    };
+                                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                    readonly name: "can";
+                                };
+                                mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    audience?: string | undefined;
+                                    ttlSeconds: number;
+                                    grant?: unknown;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: string;
+                                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                    readonly name: "mint";
+                                };
+                                whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                    readonly mode: 'value';
+                                    readonly value: {
+                                        id: string;
+                                        issuer: string;
+                                        subject: string;
+                                        frozen: boolean;
+                                        requiredClaims: ({
+                                            claim: string;
+                                            op: "contains";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "eq";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "exists";
+                                        })[];
+                                    };
+                                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                    readonly name: "whoami";
+                                };
+                                whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    issuer: string;
+                                    subject: string;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: {
+                                        id: string;
+                                        issuer: string;
+                                        subject: string;
+                                        frozen: boolean;
+                                        requiredClaims: ({
+                                            claim: string;
+                                            op: "contains";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "eq";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "exists";
+                                        })[];
+                                    } | null;
+                                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                    readonly name: "whois";
+                                };
+                            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                policy: string;
+                                object: string;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: {
+                                    allowed: boolean;
+                                };
+                            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                readonly name: "can";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                audience?: string | undefined;
+                                ttlSeconds: number;
+                                grant?: unknown;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: string;
+                            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                readonly name: "mint";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                readonly mode: 'value';
+                                readonly value: {
+                                    id: string;
+                                    issuer: string;
+                                    subject: string;
+                                    frozen: boolean;
+                                    requiredClaims: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[];
+                                };
+                            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                readonly name: "whoami";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                issuer: string;
+                                subject: string;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: {
+                                    id: string;
+                                    issuer: string;
+                                    subject: string;
+                                    frozen: boolean;
+                                    requiredClaims: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[];
+                                } | null;
+                            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                readonly name: "whois";
+                            })> & {
+                                readonly byKey: Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        policy: string;
+                                        object: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            allowed: boolean;
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                        readonly name: "can";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience?: string | undefined;
+                                        ttlSeconds: number;
+                                        grant?: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                        readonly name: "mint";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                        readonly name: "whoami";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        issuer: string;
+                                        subject: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        } | null;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                        readonly name: "whois";
+                                    };
+                                }>;
+                                get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        policy: string;
+                                        object: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            allowed: boolean;
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                        readonly name: "can";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience?: string | undefined;
+                                        ttlSeconds: number;
+                                        grant?: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                        readonly name: "mint";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                        readonly name: "whoami";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        issuer: string;
+                                        subject: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        } | null;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                        readonly name: "whois";
+                                    };
+                                }>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, Readonly<Readonly<{
+                                frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                    readonly name: "frozen";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                                };
+                                iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                    readonly name: "iss";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                                };
+                                requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                    claim: string;
+                                    op: "contains";
+                                    value: unknown;
+                                } | {
+                                    claim: string;
+                                    op: "eq";
+                                    value: unknown;
+                                } | {
+                                    claim: string;
+                                    op: "exists";
+                                })[], false> & {
+                                    readonly name: "requiredClaims";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                                };
+                                sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                    readonly name: "sub";
+                                    readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                                };
+                            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                readonly name: "frozen";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                readonly name: "iss";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                claim: string;
+                                op: "contains";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "eq";
+                                value: unknown;
+                            } | {
+                                claim: string;
+                                op: "exists";
+                            })[], false> & {
+                                readonly name: "requiredClaims";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                readonly name: "sub";
+                                readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                            })> & {
+                                readonly byKey: Readonly<{
+                                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                        readonly name: "frozen";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "iss";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[], false> & {
+                                        readonly name: "requiredClaims";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "sub";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                                    };
+                                }>;
+                                get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
+                                    "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                                        readonly name: "frozen";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "iss";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.iss";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[], false> & {
+                                        readonly name: "requiredClaims";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                                        readonly name: "sub";
+                                        readonly key: "kernel.astrale.ai:class.Identity.property.sub";
+                                    };
+                                }>[Key];
+                                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                                from(input: Readonly<{
+                                    readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[] | undefined;
+                                    readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                } & {
+                                    readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                    readonly requiredClaims?: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[] | undefined;
+                                    readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
+                                }>): import("@astrale-os/sdk/schema").PropertyValues;
+                            }, Readonly<Readonly<{
+                                delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    audience: string;
+                                    ttlSeconds: number;
+                                    attenuation: unknown;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: string;
+                                }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                    readonly name: "delegate";
+                                };
+                            }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                audience: string;
+                                ttlSeconds: number;
+                                attenuation: unknown;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: string;
+                            }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                readonly name: "delegate";
+                            }> & {
+                                readonly byKey: Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience: string;
+                                        ttlSeconds: number;
+                                        attenuation: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                        readonly name: "delegate";
+                                    };
+                                }>;
+                                get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience: string;
+                                        ttlSeconds: number;
+                                        attenuation: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
+                                        readonly name: "delegate";
+                                    };
+                                }>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, Readonly<Readonly<{
+                                can: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    policy: string;
+                                    object: string;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: {
+                                        allowed: boolean;
+                                    };
+                                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                    readonly name: "can";
+                                };
+                                mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    audience?: string | undefined;
+                                    ttlSeconds: number;
+                                    grant?: unknown;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: string;
+                                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                    readonly name: "mint";
+                                };
+                                whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                    readonly mode: 'value';
+                                    readonly value: {
+                                        id: string;
+                                        issuer: string;
+                                        subject: string;
+                                        frozen: boolean;
+                                        requiredClaims: ({
+                                            claim: string;
+                                            op: "contains";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "eq";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "exists";
+                                        })[];
+                                    };
+                                }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                    readonly name: "whoami";
+                                };
+                                whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                    issuer: string;
+                                    subject: string;
+                                }, {
+                                    readonly mode: 'value';
+                                    readonly value: {
+                                        id: string;
+                                        issuer: string;
+                                        subject: string;
+                                        frozen: boolean;
+                                        requiredClaims: ({
+                                            claim: string;
+                                            op: "contains";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "eq";
+                                            value: unknown;
+                                        } | {
+                                            claim: string;
+                                            op: "exists";
+                                        })[];
+                                    } | null;
+                                }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                    readonly name: "whois";
+                                };
+                            }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                policy: string;
+                                object: string;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: {
+                                    allowed: boolean;
+                                };
+                            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                readonly name: "can";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                audience?: string | undefined;
+                                ttlSeconds: number;
+                                grant?: unknown;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: string;
+                            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                readonly name: "mint";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                readonly mode: 'value';
+                                readonly value: {
+                                    id: string;
+                                    issuer: string;
+                                    subject: string;
+                                    frozen: boolean;
+                                    requiredClaims: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[];
+                                };
+                            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                readonly name: "whoami";
+                            }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                issuer: string;
+                                subject: string;
+                            }, {
+                                readonly mode: 'value';
+                                readonly value: {
+                                    id: string;
+                                    issuer: string;
+                                    subject: string;
+                                    frozen: boolean;
+                                    requiredClaims: ({
+                                        claim: string;
+                                        op: "contains";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "eq";
+                                        value: unknown;
+                                    } | {
+                                        claim: string;
+                                        op: "exists";
+                                    })[];
+                                } | null;
+                            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                readonly name: "whois";
+                            })> & {
+                                readonly byKey: Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        policy: string;
+                                        object: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            allowed: boolean;
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                        readonly name: "can";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience?: string | undefined;
+                                        ttlSeconds: number;
+                                        grant?: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                        readonly name: "mint";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                        readonly name: "whoami";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        issuer: string;
+                                        subject: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        } | null;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                        readonly name: "whois";
+                                    };
+                                }>;
+                                get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
+                                    "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        policy: string;
+                                        object: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            allowed: boolean;
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
+                                        readonly name: "can";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        audience?: string | undefined;
+                                        ttlSeconds: number;
+                                        grant?: unknown;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: string;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
+                                        readonly name: "mint";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        };
+                                    }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
+                                        readonly name: "whoami";
+                                    };
+                                    "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
+                                        issuer: string;
+                                        subject: string;
+                                    }, {
+                                        readonly mode: 'value';
+                                        readonly value: {
+                                            id: string;
+                                            issuer: string;
+                                            subject: string;
+                                            frozen: boolean;
+                                            requiredClaims: ({
+                                                claim: string;
+                                                op: "contains";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "eq";
+                                                value: unknown;
+                                            } | {
+                                                claim: string;
+                                                op: "exists";
+                                            })[];
+                                        } | null;
+                                    }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+                                        readonly name: "whois";
+                                    };
+                                }>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
+                                    readonly origin: "kernel.astrale.ai";
+                                };
+                                readonly kind: 'node';
+                                readonly abstract: true;
+                            }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
+                                readonly byKey: Readonly<{}>;
+                                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                                from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
+                            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                                readonly byKey: Readonly<{}>;
+                                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                                readonly byKey: Readonly<{}>;
+                                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                                readonly byKey: Readonly<{}>;
+                                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                                get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
+                                from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
+                            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                                readonly byKey: Readonly<{}>;
+                                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, Readonly<Readonly<{}>> & Iterable<never> & {
+                                readonly byKey: Readonly<{}>;
+                                get<Key extends never>(key: Key): Readonly<{}>[Key];
+                                get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
+                            }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                                    readonly origin: "kernel.astrale.ai";
+                                };
+                                readonly kind: 'node';
+                                readonly abstract: true;
+                            }, readonly []> & {
+                                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                                    readonly origin: "kernel.astrale.ai";
+                                };
+                                readonly key: "kernel.astrale.ai:class.Node";
+                            }]> & {
+                                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
+                                    readonly origin: "kernel.astrale.ai";
+                                };
+                                readonly key: "kernel.astrale.ai:class.Identity";
                             }];
+                            readonly properties: {
+                                displayName: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {
+                                    readonly required: false;
+                                }>;
+                            };
+                            readonly methods: {
+                                readonly resolveHome: import("@astrale-os/sdk/schema").Method<{
+                                    readonly description: "Resolve this User and its canonical personal Space.";
+                                    readonly auth: "authenticated";
+                                    readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+                                    readonly output: import("zod").ZodObject<{
+                                        userId: import("zod").ZodString;
+                                        personalSpaceId: import("zod").ZodNullable<import("zod").ZodString>;
+                                    }, import("zod/v4/core").$strict>;
+                                }>;
+                            };
                         }>]>;
                     }, import("zod/v4/core").$strict>;
                     readonly output: {
@@ -282,12 +4303,11 @@ export declare const administers_group: import("@astrale-os/sdk/schema").Directe
                         additionalProperties: boolean;
                     };
                     readonly auth: "authorized";
-                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                    readonly policy: ({ check, ref }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
                 }>;
             };
         }>];
         readonly incoming: "0..*";
     };
-    readonly description: "Authority to administer one Shell Group.";
-}, "source" | "target">>;
-//# sourceMappingURL=relationships.d.ts.map
+    readonly description: "Shell product membership.";
+}>;