@astrale-domains/shell 0.1.0-beta.4

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

@@ -0,0 +1,795 @@
+export declare const installed_in: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly as: "application";
+    readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
+        readonly description: "A property-free Space association for one installed Domain.";
+        readonly methods: {
+            install: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Convergently associate one installed Domain with one Space.";
+                readonly static: true;
+                readonly input: import("zod").ZodObject<{
+                    domain: import("@astrale-os/sdk/schema").Path<readonly [{
+                        origin: string;
+                        kind: 'class';
+                        name: string;
+                    }]>;
+                    space: import("@astrale-os/sdk/schema").Path<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;
+                            }>;
+                        };
+                    }>]>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly application: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly id: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    type: 'string';
+                                    pattern: string;
+                                };
+                                readonly class: {
+                                    readonly const: "Application";
+                                };
+                            };
+                            readonly required: readonly ["id", "path", "class"];
+                            readonly additionalProperties: false;
+                        };
+                        readonly domain: {
+                            type: 'string';
+                            pattern: string;
+                        };
+                        readonly space: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly id: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    type: 'string';
+                                    pattern: string;
+                                };
+                                readonly class: {
+                                    readonly const: "Space";
+                                };
+                            };
+                            readonly required: readonly ["id", "path", "class"];
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly required: readonly ["application", "domain", "space"];
+                    readonly additionalProperties: false;
+                } & import("@astrale-os/sdk/schema").TypedValueSchema<import("./methods.js").InstallApplicationResult>;
+                readonly auth: "authorized";
+                readonly policy: ({ check, input }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            uninstall: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Remove this Application association without uninstalling its Domain.";
+                readonly input: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                } & import("@astrale-os/sdk/schema").TypedValueSchema<import("./methods.js").UninstallApplicationResult>;
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+        };
+    }>];
+    readonly outgoing: "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: "application";
+        readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
+            readonly description: "A property-free Space association for one installed Domain.";
+            readonly methods: {
+                install: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Convergently associate one installed Domain with one Space.";
+                    readonly static: true;
+                    readonly input: import("zod").ZodObject<{
+                        domain: import("@astrale-os/sdk/schema").Path<readonly [{
+                            origin: string;
+                            kind: 'class';
+                            name: string;
+                        }]>;
+                        space: import("@astrale-os/sdk/schema").Path<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;
+                                }>;
+                            };
+                        }>]>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly application: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly id: {
+                                        readonly type: "string";
+                                    };
+                                    readonly path: {
+                                        type: 'string';
+                                        pattern: string;
+                                    };
+                                    readonly class: {
+                                        readonly const: "Application";
+                                    };
+                                };
+                                readonly required: readonly ["id", "path", "class"];
+                                readonly additionalProperties: false;
+                            };
+                            readonly domain: {
+                                type: 'string';
+                                pattern: string;
+                            };
+                            readonly space: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly id: {
+                                        readonly type: "string";
+                                    };
+                                    readonly path: {
+                                        type: 'string';
+                                        pattern: string;
+                                    };
+                                    readonly class: {
+                                        readonly const: "Space";
+                                    };
+                                };
+                                readonly required: readonly ["id", "path", "class"];
+                                readonly additionalProperties: false;
+                            };
+                        };
+                        readonly required: readonly ["application", "domain", "space"];
+                        readonly additionalProperties: false;
+                    } & import("@astrale-os/sdk/schema").TypedValueSchema<import("./methods.js").InstallApplicationResult>;
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, input }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                uninstall: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Remove this Application association without uninstalling its Domain.";
+                    readonly input: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    } & import("@astrale-os/sdk/schema").TypedValueSchema<import("./methods.js").UninstallApplicationResult>;
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>];
+        readonly outgoing: "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: "The one Space containing an Application.";
+}, "source" | "target">>;
+export declare const application_of: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly as: "application";
+    readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
+        readonly description: "A property-free Space association for one installed Domain.";
+        readonly methods: {
+            install: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Convergently associate one installed Domain with one Space.";
+                readonly static: true;
+                readonly input: import("zod").ZodObject<{
+                    domain: import("@astrale-os/sdk/schema").Path<readonly [{
+                        origin: string;
+                        kind: 'class';
+                        name: string;
+                    }]>;
+                    space: import("@astrale-os/sdk/schema").Path<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;
+                            }>;
+                        };
+                    }>]>;
+                }, import("zod/v4/core").$strict>;
+                readonly output: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly application: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly id: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    type: 'string';
+                                    pattern: string;
+                                };
+                                readonly class: {
+                                    readonly const: "Application";
+                                };
+                            };
+                            readonly required: readonly ["id", "path", "class"];
+                            readonly additionalProperties: false;
+                        };
+                        readonly domain: {
+                            type: 'string';
+                            pattern: string;
+                        };
+                        readonly space: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly id: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    type: 'string';
+                                    pattern: string;
+                                };
+                                readonly class: {
+                                    readonly const: "Space";
+                                };
+                            };
+                            readonly required: readonly ["id", "path", "class"];
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly required: readonly ["application", "domain", "space"];
+                    readonly additionalProperties: false;
+                } & import("@astrale-os/sdk/schema").TypedValueSchema<import("./methods.js").InstallApplicationResult>;
+                readonly auth: "authorized";
+                readonly policy: ({ check, input }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+            uninstall: import("@astrale-os/sdk/schema").Function<{
+                readonly description: "Remove this Application association without uninstalling its Domain.";
+                readonly input: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                };
+                readonly output: {
+                    type: 'object';
+                    properties: {};
+                    additionalProperties: boolean;
+                } & import("@astrale-os/sdk/schema").TypedValueSchema<import("./methods.js").UninstallApplicationResult>;
+                readonly auth: "authorized";
+                readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+            }>;
+        };
+    }>];
+    readonly outgoing: "1";
+}, {
+    readonly as: "domain";
+    readonly accepts: readonly [{
+        origin: "kernel.astrale.ai";
+        kind: 'class';
+        name: "Domain";
+    }];
+    readonly incoming: "0..*";
+}, Omit<{
+    readonly source: {
+        readonly as: "application";
+        readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
+            readonly description: "A property-free Space association for one installed Domain.";
+            readonly methods: {
+                install: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Convergently associate one installed Domain with one Space.";
+                    readonly static: true;
+                    readonly input: import("zod").ZodObject<{
+                        domain: import("@astrale-os/sdk/schema").Path<readonly [{
+                            origin: string;
+                            kind: 'class';
+                            name: string;
+                        }]>;
+                        space: import("@astrale-os/sdk/schema").Path<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;
+                                }>;
+                            };
+                        }>]>;
+                    }, import("zod/v4/core").$strict>;
+                    readonly output: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly application: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly id: {
+                                        readonly type: "string";
+                                    };
+                                    readonly path: {
+                                        type: 'string';
+                                        pattern: string;
+                                    };
+                                    readonly class: {
+                                        readonly const: "Application";
+                                    };
+                                };
+                                readonly required: readonly ["id", "path", "class"];
+                                readonly additionalProperties: false;
+                            };
+                            readonly domain: {
+                                type: 'string';
+                                pattern: string;
+                            };
+                            readonly space: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly id: {
+                                        readonly type: "string";
+                                    };
+                                    readonly path: {
+                                        type: 'string';
+                                        pattern: string;
+                                    };
+                                    readonly class: {
+                                        readonly const: "Space";
+                                    };
+                                };
+                                readonly required: readonly ["id", "path", "class"];
+                                readonly additionalProperties: false;
+                            };
+                        };
+                        readonly required: readonly ["application", "domain", "space"];
+                        readonly additionalProperties: false;
+                    } & import("@astrale-os/sdk/schema").TypedValueSchema<import("./methods.js").InstallApplicationResult>;
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, input }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+                uninstall: import("@astrale-os/sdk/schema").Function<{
+                    readonly description: "Remove this Application association without uninstalling its Domain.";
+                    readonly input: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    };
+                    readonly output: {
+                        type: 'object';
+                        properties: {};
+                        additionalProperties: boolean;
+                    } & import("@astrale-os/sdk/schema").TypedValueSchema<import("./methods.js").UninstallApplicationResult>;
+                    readonly auth: "authorized";
+                    readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
+                }>;
+            };
+        }>];
+        readonly outgoing: "1";
+    };
+    readonly target: {
+        readonly as: "domain";
+        readonly accepts: readonly [{
+            origin: "kernel.astrale.ai";
+            kind: 'class';
+            name: "Domain";
+        }];
+        readonly incoming: "0..*";
+    };
+    readonly description: "The installed Domain represented by an Application.";
+}, "source" | "target">>;
+//# sourceMappingURL=relationships.d.ts.map