@astrale-domains/shell 0.1.0-beta.4

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

@@ -0,0 +1,1059 @@
+export declare const owns_space: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly as: "owner";
+    readonly accepts: readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+        readonly description: "A human-facing Shell principal.";
+        readonly extends: readonly [{
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: "Identity";
+        }];
+    }>, import("@astrale-os/sdk/schema").NodeClass<{
+        readonly description: "A named compositional Shell Identity.";
+        readonly implements: readonly [{
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }, {
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }, {
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }];
+        readonly methods: {
+            assignUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: string;
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            unassignUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: string;
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+        };
+    }>];
+    readonly outgoing: "0..*";
+}, {
+    readonly as: "space";
+    readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
+        readonly description: "A named Shell collaboration boundary.";
+        readonly implements: readonly [{
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }, {
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }];
+        readonly methods: {
+            addUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Set one User direct member or admin access.";
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                    access: import("zod").ZodEnum<{
+                        admin: "admin";
+                        member: "member";
+                    }>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            removeUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Remove one User direct access.";
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            setDefault: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Set this accessible Space as the granted User fallback.";
+                readonly input: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+        };
+    }>];
+    readonly incoming: "1";
+}, Omit<{
+    readonly source: {
+        readonly as: "owner";
+        readonly accepts: readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+            readonly description: "A human-facing Shell principal.";
+            readonly extends: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: "Identity";
+            }];
+        }>, import("@astrale-os/sdk/schema").NodeClass<{
+            readonly description: "A named compositional Shell Identity.";
+            readonly implements: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }, {
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }, {
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }];
+            readonly methods: {
+                assignUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: string;
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                unassignUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: string;
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>];
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "space";
+        readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
+            readonly description: "A named Shell collaboration boundary.";
+            readonly implements: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }, {
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }];
+            readonly methods: {
+                addUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Set one User direct member or admin access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                        access: import("zod").ZodEnum<{
+                            admin: "admin";
+                            member: "member";
+                        }>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                removeUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Remove one User direct access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                setDefault: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Set this accessible Space as the granted User fallback.";
+                    readonly input: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>];
+        readonly incoming: "1";
+    };
+    readonly description: "The unique owner of a Space.";
+}, "source" | "target">>;
+export declare const administers_space: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly as: "admin";
+    readonly accepts: readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+        readonly description: "A human-facing Shell principal.";
+        readonly extends: readonly [{
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: "Identity";
+        }];
+    }>, import("@astrale-os/sdk/schema").NodeClass<{
+        readonly description: "A named compositional Shell Identity.";
+        readonly implements: readonly [{
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }, {
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }, {
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }];
+        readonly methods: {
+            assignUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: string;
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            unassignUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: string;
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+        };
+    }>];
+    readonly outgoing: "0..*";
+}, {
+    readonly as: "space";
+    readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
+        readonly description: "A named Shell collaboration boundary.";
+        readonly implements: readonly [{
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }, {
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }];
+        readonly methods: {
+            addUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Set one User direct member or admin access.";
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                    access: import("zod").ZodEnum<{
+                        admin: "admin";
+                        member: "member";
+                    }>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            removeUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Remove one User direct access.";
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            setDefault: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Set this accessible Space as the granted User fallback.";
+                readonly input: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+        };
+    }>];
+    readonly incoming: "0..*";
+}, Omit<{
+    readonly source: {
+        readonly as: "admin";
+        readonly accepts: readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+            readonly description: "A human-facing Shell principal.";
+            readonly extends: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: "Identity";
+            }];
+        }>, import("@astrale-os/sdk/schema").NodeClass<{
+            readonly description: "A named compositional Shell Identity.";
+            readonly implements: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }, {
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }, {
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }];
+            readonly methods: {
+                assignUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: string;
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                unassignUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: string;
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>];
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "space";
+        readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
+            readonly description: "A named Shell collaboration boundary.";
+            readonly implements: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }, {
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }];
+            readonly methods: {
+                addUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Set one User direct member or admin access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                        access: import("zod").ZodEnum<{
+                            admin: "admin";
+                            member: "member";
+                        }>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                removeUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Remove one User direct access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                setDefault: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Set this accessible Space as the granted User fallback.";
+                    readonly input: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>];
+        readonly incoming: "0..*";
+    };
+    readonly description: "Direct Space administration.";
+}, "source" | "target">>;
+export declare const member_of_space: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly as: "member";
+    readonly accepts: readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+        readonly description: "A human-facing Shell principal.";
+        readonly extends: readonly [{
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: "Identity";
+        }];
+    }>, import("@astrale-os/sdk/schema").NodeClass<{
+        readonly description: "A named compositional Shell Identity.";
+        readonly implements: readonly [{
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }, {
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }, {
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }];
+        readonly methods: {
+            assignUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: string;
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            unassignUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: string;
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+        };
+    }>];
+    readonly outgoing: "0..*";
+}, {
+    readonly as: "space";
+    readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
+        readonly description: "A named Shell collaboration boundary.";
+        readonly implements: readonly [{
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }, {
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }];
+        readonly methods: {
+            addUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Set one User direct member or admin access.";
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                    access: import("zod").ZodEnum<{
+                        admin: "admin";
+                        member: "member";
+                    }>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            removeUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Remove one User direct access.";
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            setDefault: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Set this accessible Space as the granted User fallback.";
+                readonly input: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+        };
+    }>];
+    readonly incoming: "0..*";
+}, Omit<{
+    readonly source: {
+        readonly as: "member";
+        readonly accepts: readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+            readonly description: "A human-facing Shell principal.";
+            readonly extends: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: "Identity";
+            }];
+        }>, import("@astrale-os/sdk/schema").NodeClass<{
+            readonly description: "A named compositional Shell Identity.";
+            readonly implements: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }, {
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }, {
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }];
+            readonly methods: {
+                assignUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: string;
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                unassignUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: string;
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>];
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "space";
+        readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
+            readonly description: "A named Shell collaboration boundary.";
+            readonly implements: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }, {
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }];
+            readonly methods: {
+                addUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Set one User direct member or admin access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                        access: import("zod").ZodEnum<{
+                            admin: "admin";
+                            member: "member";
+                        }>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                removeUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Remove one User direct access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                setDefault: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Set this accessible Space as the granted User fallback.";
+                    readonly input: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>];
+        readonly incoming: "0..*";
+    };
+    readonly description: "Direct Space membership.";
+}, "source" | "target">>;
+export declare const default_space: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly as: "user";
+    readonly accepts: readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+        readonly description: "A human-facing Shell principal.";
+        readonly extends: readonly [{
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: "Identity";
+        }];
+    }>];
+    readonly outgoing: "0..1";
+}, {
+    readonly as: "space";
+    readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
+        readonly description: "A named Shell collaboration boundary.";
+        readonly implements: readonly [{
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }, {
+            origin: "kernel.astrale.ai";
+            kind: 'interface';
+            name: string;
+        }];
+        readonly methods: {
+            addUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Set one User direct member or admin access.";
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                    access: import("zod").ZodEnum<{
+                        admin: "admin";
+                        member: "member";
+                    }>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            removeUser: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Remove one User direct access.";
+                readonly input: import("zod").ZodObject<{
+                    user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                        readonly description: "A human-facing Shell principal.";
+                        readonly extends: readonly [{
+                            origin: "kernel.astrale.ai";
+                            kind: 'interface';
+                            name: "Identity";
+                        }];
+                    }>]>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            setDefault: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Set this accessible Space as the granted User fallback.";
+                readonly input: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+        };
+    }>];
+    readonly incoming: "0..*";
+}, Omit<{
+    readonly source: {
+        readonly as: "user";
+        readonly accepts: readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+            readonly description: "A human-facing Shell principal.";
+            readonly extends: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: "Identity";
+            }];
+        }>];
+        readonly outgoing: "0..1";
+    };
+    readonly target: {
+        readonly as: "space";
+        readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
+            readonly description: "A named Shell collaboration boundary.";
+            readonly implements: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }, {
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: string;
+            }];
+            readonly methods: {
+                addUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Set one User direct member or admin access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                        access: import("zod").ZodEnum<{
+                            admin: "admin";
+                            member: "member";
+                        }>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                removeUser: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Remove one User direct access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: import("@astrale-os/sdk/schema").Path<readonly [import("@astrale-os/sdk/schema").NodeInterface<{
+                            readonly description: "A human-facing Shell principal.";
+                            readonly extends: readonly [{
+                                origin: "kernel.astrale.ai";
+                                kind: 'interface';
+                                name: "Identity";
+                            }];
+                        }>]>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                setDefault: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Set this accessible Space as the granted User fallback.";
+                    readonly input: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>];
+        readonly incoming: "0..*";
+    };
+    readonly description: "One User persisted fallback Space.";
+}, "source" | "target">>;
+//# sourceMappingURL=relationships.d.ts.map