@astrale-domains/shell 0.1.0-beta.4

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

@@ -0,0 +1,995 @@
+import { type builder } from '@astrale-os/sdk/schema';
+export declare const defaultSpace: builder.Node<builder.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: builder.Function<{
+            readonly description: "Set one User direct member or admin access.";
+            readonly input: import("zod").ZodObject<{
+                user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+        }>;
+        removeUser: builder.Function<{
+            readonly description: "Remove one User direct access.";
+            readonly input: import("zod").ZodObject<{
+                user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+        }>;
+        setDefault: builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+        }>;
+    };
+}>>;
+export declare const spaceCore: {
+    nodes: {
+        'default-space': builder.Node<builder.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: builder.Function<{
+                    readonly description: "Set one User direct member or admin access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                removeUser: builder.Function<{
+                    readonly description: "Remove one User direct access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                setDefault: builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>>;
+    };
+    edges: (builder.Edge<builder.Node<builder.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: builder.Function<{
+                readonly description: string;
+                readonly input: import("zod").ZodObject<{
+                    user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            unassignUser: builder.Function<{
+                readonly description: string;
+                readonly input: import("zod").ZodObject<{
+                    user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+        };
+    }>>, builder.DirectedEdgeClass<{
+        readonly as: "owner";
+        readonly accepts: readonly [builder.NodeInterface<{
+            readonly description: "A human-facing Shell principal.";
+            readonly extends: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: "Identity";
+            }];
+        }>, builder.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: builder.Function<{
+                    readonly description: string;
+                    readonly input: import("zod").ZodObject<{
+                        user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                unassignUser: builder.Function<{
+                    readonly description: string;
+                    readonly input: import("zod").ZodObject<{
+                        user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>];
+        readonly outgoing: "0..*";
+    }, {
+        readonly as: "space";
+        readonly accepts: readonly [() => builder.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: builder.Function<{
+                    readonly description: "Set one User direct member or admin access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                removeUser: builder.Function<{
+                    readonly description: "Remove one User direct access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                setDefault: builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>];
+        readonly incoming: "1";
+    }, Omit<{
+        readonly source: {
+            readonly as: "owner";
+            readonly accepts: readonly [builder.NodeInterface<{
+                readonly description: "A human-facing Shell principal.";
+                readonly extends: readonly [{
+                    origin: "kernel.astrale.ai";
+                    kind: 'interface';
+                    name: "Identity";
+                }];
+            }>, builder.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: builder.Function<{
+                        readonly description: string;
+                        readonly input: import("zod").ZodObject<{
+                            user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                    }>;
+                    unassignUser: builder.Function<{
+                        readonly description: string;
+                        readonly input: import("zod").ZodObject<{
+                            user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                    }>;
+                };
+            }>];
+            readonly outgoing: "0..*";
+        };
+        readonly target: {
+            readonly as: "space";
+            readonly accepts: readonly [() => builder.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: builder.Function<{
+                        readonly description: "Set one User direct member or admin access.";
+                        readonly input: import("zod").ZodObject<{
+                            user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                    }>;
+                    removeUser: builder.Function<{
+                        readonly description: "Remove one User direct access.";
+                        readonly input: import("zod").ZodObject<{
+                            user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                    }>;
+                    setDefault: builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                    }>;
+                };
+            }>];
+            readonly incoming: "1";
+        };
+        readonly description: "The unique owner of a Space.";
+    }, "source" | "target">>, builder.Node<builder.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: builder.Function<{
+                readonly description: "Set one User direct member or admin access.";
+                readonly input: import("zod").ZodObject<{
+                    user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            removeUser: builder.Function<{
+                readonly description: "Remove one User direct access.";
+                readonly input: import("zod").ZodObject<{
+                    user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            setDefault: builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+        };
+    }>>> | builder.Edge<builder.Node<builder.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: builder.Function<{
+                readonly description: string;
+                readonly input: import("zod").ZodObject<{
+                    user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            unassignUser: builder.Function<{
+                readonly description: string;
+                readonly input: import("zod").ZodObject<{
+                    user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+        };
+    }>>, builder.DirectedEdgeClass<{
+        readonly as: "member";
+        readonly accepts: readonly [builder.NodeInterface<{
+            readonly description: "A human-facing Shell principal.";
+            readonly extends: readonly [{
+                origin: "kernel.astrale.ai";
+                kind: 'interface';
+                name: "Identity";
+            }];
+        }>, builder.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: builder.Function<{
+                    readonly description: string;
+                    readonly input: import("zod").ZodObject<{
+                        user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                unassignUser: builder.Function<{
+                    readonly description: string;
+                    readonly input: import("zod").ZodObject<{
+                        user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>];
+        readonly outgoing: "0..*";
+    }, {
+        readonly as: "space";
+        readonly accepts: readonly [() => builder.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: builder.Function<{
+                    readonly description: "Set one User direct member or admin access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                removeUser: builder.Function<{
+                    readonly description: "Remove one User direct access.";
+                    readonly input: import("zod").ZodObject<{
+                        user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                setDefault: builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>];
+        readonly incoming: "0..*";
+    }, Omit<{
+        readonly source: {
+            readonly as: "member";
+            readonly accepts: readonly [builder.NodeInterface<{
+                readonly description: "A human-facing Shell principal.";
+                readonly extends: readonly [{
+                    origin: "kernel.astrale.ai";
+                    kind: 'interface';
+                    name: "Identity";
+                }];
+            }>, builder.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: builder.Function<{
+                        readonly description: string;
+                        readonly input: import("zod").ZodObject<{
+                            user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                    }>;
+                    unassignUser: builder.Function<{
+                        readonly description: string;
+                        readonly input: import("zod").ZodObject<{
+                            user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                    }>;
+                };
+            }>];
+            readonly outgoing: "0..*";
+        };
+        readonly target: {
+            readonly as: "space";
+            readonly accepts: readonly [() => builder.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: builder.Function<{
+                        readonly description: "Set one User direct member or admin access.";
+                        readonly input: import("zod").ZodObject<{
+                            user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                    }>;
+                    removeUser: builder.Function<{
+                        readonly description: "Remove one User direct access.";
+                        readonly input: import("zod").ZodObject<{
+                            user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                    }>;
+                    setDefault: builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                    }>;
+                };
+            }>];
+            readonly incoming: "0..*";
+        };
+        readonly description: "Direct Space membership.";
+    }, "source" | "target">>, builder.Node<builder.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: builder.Function<{
+                readonly description: "Set one User direct member or admin access.";
+                readonly input: import("zod").ZodObject<{
+                    user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            removeUser: builder.Function<{
+                readonly description: "Remove one User direct access.";
+                readonly input: import("zod").ZodObject<{
+                    user: builder.Path<readonly [builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            setDefault: builder.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 }: builder.CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+        };
+    }>>>)[];
+};
+//# sourceMappingURL=core.d.ts.map