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

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

@@ -1,3288 +0,0 @@
-export declare const Group: import("@astrale-os/sdk/schema").NodeClass<{
-    readonly description: "A named compositional Shell Identity.";
-    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<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";
-    }) | (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";
-    })> & {
-        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<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";
-    }) | (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";
-    })> & {
-        readonly byKey: Readonly<{
-            "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
-                policy: string;
-                object: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: {
-                    allowed: boolean;
-                };
-            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
-                readonly name: "can";
-            };
-            "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
-                readonly name: "mint";
-            };
-            "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
-                readonly mode: 'value';
-                readonly value: {
-                    id: string;
-                    issuer: string;
-                    subject: string;
-                    frozen: boolean;
-                    requiredClaims: ({
-                        claim: string;
-                        op: "contains";
-                        value: unknown;
-                    } | {
-                        claim: string;
-                        op: "eq";
-                        value: unknown;
-                    } | {
-                        claim: string;
-                        op: "exists";
-                    })[];
-                };
-            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
-                readonly name: "whoami";
-            };
-            "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
-                issuer: string;
-                subject: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: {
-                    id: string;
-                    issuer: string;
-                    subject: string;
-                    frozen: boolean;
-                    requiredClaims: ({
-                        claim: string;
-                        op: "contains";
-                        value: unknown;
-                    } | {
-                        claim: string;
-                        op: "eq";
-                        value: unknown;
-                    } | {
-                        claim: string;
-                        op: "exists";
-                    })[];
-                } | null;
-            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
-                readonly name: "whois";
-            };
-        }>;
-        get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
-            "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
-                policy: string;
-                object: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: {
-                    allowed: boolean;
-                };
-            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
-                readonly name: "can";
-            };
-            "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
-                audience?: string | undefined;
-                ttlSeconds: number;
-                grant?: unknown;
-            }, {
-                readonly mode: 'value';
-                readonly value: string;
-            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
-                readonly name: "mint";
-            };
-            "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
-                readonly mode: 'value';
-                readonly value: {
-                    id: string;
-                    issuer: string;
-                    subject: string;
-                    frozen: boolean;
-                    requiredClaims: ({
-                        claim: string;
-                        op: "contains";
-                        value: unknown;
-                    } | {
-                        claim: string;
-                        op: "eq";
-                        value: unknown;
-                    } | {
-                        claim: string;
-                        op: "exists";
-                    })[];
-                };
-            }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
-                readonly name: "whoami";
-            };
-            "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
-                issuer: string;
-                subject: string;
-            }, {
-                readonly mode: 'value';
-                readonly value: {
-                    id: string;
-                    issuer: string;
-                    subject: string;
-                    frozen: boolean;
-                    requiredClaims: ({
-                        claim: string;
-                        op: "contains";
-                        value: unknown;
-                    } | {
-                        claim: string;
-                        op: "eq";
-                        value: unknown;
-                    } | {
-                        claim: string;
-                        op: "exists";
-                    })[];
-                } | null;
-            }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
-                readonly name: "whois";
-            };
-        }>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
-        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
-            readonly origin: "kernel.astrale.ai";
-        };
-        readonly kind: 'node';
-        readonly abstract: true;
-    }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
-        from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
-        from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
-        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
-            readonly origin: "kernel.astrale.ai";
-        };
-        readonly kind: 'node';
-        readonly abstract: true;
-    }, readonly []> & {
-        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
-            readonly origin: "kernel.astrale.ai";
-        };
-        readonly key: "kernel.astrale.ai:class.Node";
-    }]> & {
-        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
-            readonly origin: "kernel.astrale.ai";
-        };
-        readonly key: "kernel.astrale.ai:class.Identity";
-    }, import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
-        name: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
-            readonly name: "name";
-            readonly key: "kernel.astrale.ai:class.Named.property.name";
-        };
-    }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
-        readonly name: "name";
-        readonly key: "kernel.astrale.ai:class.Named.property.name";
-    }> & {
-        readonly byKey: Readonly<{
-            "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
-                readonly name: "name";
-                readonly key: "kernel.astrale.ai:class.Named.property.name";
-            };
-        }>;
-        get<Key extends "kernel.astrale.ai:class.Named.property.name">(key: Key): Readonly<{
-            "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
-                readonly name: "name";
-                readonly key: "kernel.astrale.ai:class.Named.property.name";
-            };
-        }>[Key];
-        get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
-        from(input: Readonly<{
-            readonly "kernel.astrale.ai:class.Named.property.name"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
-        } & {
-            readonly name?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
-        }>): import("@astrale-os/sdk/schema").PropertyValues;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{
-        name: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
-            readonly name: "name";
-            readonly key: "kernel.astrale.ai:class.Named.property.name";
-        };
-    }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
-        readonly name: "name";
-        readonly key: "kernel.astrale.ai:class.Named.property.name";
-    }> & {
-        readonly byKey: Readonly<{
-            "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
-                readonly name: "name";
-                readonly key: "kernel.astrale.ai:class.Named.property.name";
-            };
-        }>;
-        get<Key extends "kernel.astrale.ai:class.Named.property.name">(key: Key): Readonly<{
-            "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
-                readonly name: "name";
-                readonly key: "kernel.astrale.ai:class.Named.property.name";
-            };
-        }>[Key];
-        get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
-        from(input: Readonly<{
-            readonly "kernel.astrale.ai:class.Named.property.name"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
-        } & {
-            readonly name?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
-        }>): import("@astrale-os/sdk/schema").PropertyValues;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
-        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
-            readonly origin: "kernel.astrale.ai";
-        };
-        readonly kind: 'node';
-        readonly abstract: true;
-    }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
-        from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
-        from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
-        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
-            readonly origin: "kernel.astrale.ai";
-        };
-        readonly kind: 'node';
-        readonly abstract: true;
-    }, readonly []> & {
-        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
-            readonly origin: "kernel.astrale.ai";
-        };
-        readonly key: "kernel.astrale.ai:class.Node";
-    }]> & {
-        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
-            readonly origin: "kernel.astrale.ai";
-        };
-        readonly key: "kernel.astrale.ai:class.Named";
-    }, import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
-        description: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
-            readonly name: "description";
-            readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
-        };
-    }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
-        readonly name: "description";
-        readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
-    }> & {
-        readonly byKey: Readonly<{
-            "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
-                readonly name: "description";
-                readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
-            };
-        }>;
-        get<Key extends "kernel.astrale.ai:class.Descriptable.property.description">(key: Key): Readonly<{
-            "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
-                readonly name: "description";
-                readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
-            };
-        }>[Key];
-        get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
-        from(input: Readonly<{
-            readonly "kernel.astrale.ai:class.Descriptable.property.description"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
-        } & {
-            readonly description?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
-        }>): import("@astrale-os/sdk/schema").PropertyValues;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{
-        description: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
-            readonly name: "description";
-            readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
-        };
-    }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
-        readonly name: "description";
-        readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
-    }> & {
-        readonly byKey: Readonly<{
-            "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
-                readonly name: "description";
-                readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
-            };
-        }>;
-        get<Key extends "kernel.astrale.ai:class.Descriptable.property.description">(key: Key): Readonly<{
-            "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
-                readonly name: "description";
-                readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
-            };
-        }>[Key];
-        get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
-        from(input: Readonly<{
-            readonly "kernel.astrale.ai:class.Descriptable.property.description"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
-        } & {
-            readonly description?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
-        }>): import("@astrale-os/sdk/schema").PropertyValues;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
-        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
-            readonly origin: "kernel.astrale.ai";
-        };
-        readonly kind: 'node';
-        readonly abstract: true;
-    }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
-        from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
-        from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, Readonly<Readonly<{}>> & Iterable<never> & {
-        readonly byKey: Readonly<{}>;
-        get<Key extends never>(key: Key): Readonly<{}>[Key];
-        get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
-    }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
-        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
-            readonly origin: "kernel.astrale.ai";
-        };
-        readonly kind: 'node';
-        readonly abstract: true;
-    }, readonly []> & {
-        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
-            readonly origin: "kernel.astrale.ai";
-        };
-        readonly key: "kernel.astrale.ai:class.Node";
-    }]> & {
-        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
-            readonly origin: "kernel.astrale.ai";
-        };
-        readonly key: "kernel.astrale.ai:class.Descriptable";
-    }];
-    readonly methods: {
-        assignUser: import("@astrale-os/sdk/schema").Method<{
-            readonly description: string;
-            readonly input: import("zod").ZodObject<{
-                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<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";
-                    }) | (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";
-                    })> & {
-                        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<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";
-                    }) | (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";
-                    })> & {
-                        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: {
-                type: 'object';
-                properties: {};
-                additionalProperties: boolean;
-            };
-            readonly auth: "authorized";
-            readonly policy: ({ check, ref }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-        }>;
-        unassignUser: import("@astrale-os/sdk/schema").Method<{
-            readonly description: string;
-            readonly input: import("zod").ZodObject<{
-                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<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";
-                    }) | (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";
-                    })> & {
-                        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<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";
-                    }) | (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";
-                    })> & {
-                        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: {
-                type: 'object';
-                properties: {};
-                additionalProperties: boolean;
-            };
-            readonly auth: "authorized";
-            readonly policy: ({ check, ref }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
-        }>;
-    };
-}>;