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

package/dist/schema/space/class.d.ts

@@ -1,25 +1,1259 @@
 export declare const Space: import("@astrale-os/sdk/schema").NodeClass<{
     readonly description: "A named Shell collaboration boundary.";
-    readonly implements: readonly [{
-        origin: "kernel.astrale.ai";
-        kind: 'interface';
-        name: string;
-    }, {
-        origin: "kernel.astrale.ai";
-        kind: 'interface';
-        name: string;
+    readonly extends: readonly [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: {
-        addUser: import("@astrale-os/sdk/schema").Function<{
+        addUser: import("@astrale-os/sdk/schema").Method<{
             readonly description: "Set one User direct member or admin access.";
             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>;
+                        }>;
+                    };
                 }>]>;
                 access: import("zod").ZodEnum<{
                     admin: "admin";
@@ -34,16 +1268,1022 @@ export declare const Space: import("@astrale-os/sdk/schema").NodeClass<{
             readonly auth: "authorized";
             readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
         }>;
-        removeUser: import("@astrale-os/sdk/schema").Function<{
+        removeUser: import("@astrale-os/sdk/schema").Method<{
             readonly description: "Remove one User direct access.";
             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: {
@@ -54,7 +2294,7 @@ export declare const Space: import("@astrale-os/sdk/schema").NodeClass<{
             readonly auth: "authorized";
             readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
         }>;
-        setDefault: import("@astrale-os/sdk/schema").Function<{
+        setDefault: import("@astrale-os/sdk/schema").Method<{
             readonly description: "Set this accessible Space as the granted User fallback.";
             readonly input: {
                 type: 'object';
@@ -71,4 +2311,3 @@ export declare const Space: import("@astrale-os/sdk/schema").NodeClass<{
         }>;
     };
 }>;
-//# sourceMappingURL=class.d.ts.map