@astrale-os/kernel-core 0.9.0-beta.6 → 0.9.0-beta.61

package/dist/schema/callables/view-for.d.ts

@@ -1,557 +1,30 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const ViewFor: builder.DirectedEdgeClass<{
-    readonly as: "view";
-    readonly accepts: readonly [builder.NodeClass<{
-        readonly description: "The installed projection of a declarative browser surface; it is not a principal.";
-        readonly implements: readonly [builder.NodeInterface<{
-            readonly description: "Ordinary projection-node contract for a declarative browser surface.";
-            readonly extends: readonly [builder.Interface<{
-                readonly family: "both";
-                readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
-                readonly properties: {
-                    description: builder.Property<Readonly<{
-                        readonly type: 'string';
-                        readonly minLength: 1;
-                        readonly maxLength: 1000;
-                    }>, {
-                        readonly required: false;
-                    }>;
-                };
-            }>];
-        }>];
-        readonly methods: Readonly<{
-            resolve: builder.Function<{
-                readonly description: "Resolve the installed View declarations applicable to one authorized graph target.";
-                readonly auth: "authorized";
-                readonly input: import("zod").ZodObject<{
-                    target: import("zod").ZodString;
-                }, import("zod/v4/core").$strict>;
-                readonly output: import("zod").ZodObject<{
-                    snapshot: import("zod").ZodString;
-                    views: import("zod").ZodArray<import("zod").ZodObject<{
-                        key: import("zod").ZodString;
-                        declaration: import("zod").ZodObject<{
-                            description: import("zod").ZodOptional<import("zod").ZodString>;
-                            target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                kind: import("zod").ZodLiteral<"domain">;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                kind: import("zod").ZodLiteral<"definition">;
-                                definitions: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                    origin: import("zod").ZodString;
-                                    kind: import("zod").ZodLiteral<"class">;
-                                    name: import("zod").ZodString;
-                                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                    origin: import("zod").ZodString;
-                                    kind: import("zod").ZodLiteral<"interface">;
-                                    name: import("zod").ZodString;
-                                }, import("zod/v4/core").$strict>], "kind">>;
-                            }, import("zod/v4/core").$strict>], "kind">;
-                        }, import("zod/v4/core").$strict>;
-                        href: import("zod").ZodString;
-                        handshake: import("zod").ZodEnum<{
-                            none: "none";
-                            shell: "shell";
-                        }>;
-                        issuer: import("zod").ZodString;
-                        etag: import("zod").ZodString;
-                        revision: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>>;
-                }, import("zod/v4/core").$strict>;
-                readonly static: true;
-                readonly inheritance: "sealed";
-            }>;
-        }>;
-    }>];
-    readonly outgoing: "1..*";
-}, {
-    readonly as: "target";
-    readonly accepts: readonly [builder.NodeClass<{
-        readonly description: "The installed graph projection of a concrete Node Class or Edge Class declaration.";
-        readonly implements: readonly [builder.Interface<{
-            readonly family: "both";
-            readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
-            readonly properties: {
-                description: builder.Property<Readonly<{
-                    readonly type: 'string';
-                    readonly minLength: 1;
-                    readonly maxLength: 1000;
-                }>, {
-                    readonly required: false;
-                }>;
-            };
-        }>, builder.Interface<{
-            readonly family: "both";
-            readonly description: "Optional bounded presentation icon metadata.";
-            readonly properties: {
-                icon: builder.Property<Readonly<{
-                    readonly type: 'string';
-                    readonly minLength: 1;
-                    readonly maxLength: 8000;
-                }>, {
-                    readonly required: false;
-                }>;
-            };
-        }>];
-        readonly properties: {
-            readonly family: {
-                readonly enum: readonly ["node", "edge"];
-            };
+    readonly depth: 1;
+    readonly abstract: false;
+    readonly extends: readonly [builder.ClassReferenceProjection<"edge", {
+        readonly abstract: true;
+        readonly depth: 0;
+        readonly properties: never;
+        readonly source: {
+            readonly as: "source";
+            readonly outgoing: "0..*";
         };
-    }>, builder.NodeClass<{
-        readonly description: "A stable Domain principal and the active projection of one canonical DomainSchema revision.";
-        readonly implements: readonly [builder.NodeInterface<{
-            readonly description: "A principal that can be authenticated and can originate persistent authority facts.";
-            readonly properties: {
-                readonly frozen: builder.Property<{
-                    readonly type: "boolean";
-                }, {
-                    readonly required: false;
-                    readonly visibility: "private";
-                }>;
-                readonly iss: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-                readonly requiredClaims: builder.Property<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"contains">;
-                    value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"eq">;
-                    value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"exists">;
-                }, import("zod/v4/core").$strict>], "op">>, {
-                    readonly required: false;
-                    readonly visibility: "private";
-                }>;
-                readonly sub: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-            };
-            readonly methods: Readonly<{
-                delegate: builder.Function<{
-                    readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
-                    readonly auth: "authenticated";
-                    readonly input: import("zod").ZodObject<{
-                        audience: import("zod").ZodString;
-                        ttlSeconds: import("zod").ZodNumber;
-                        attenuation: import("zod").ZodUnknown;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: import("zod").ZodString;
-                    readonly inheritance: "default";
-                }>;
-                can: builder.Function<{
-                    readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
-                    readonly auth: "authenticated";
-                    readonly input: import("zod").ZodObject<{
-                        policy: import("zod").ZodString;
-                        object: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: import("zod").ZodObject<{
-                        allowed: import("zod").ZodBoolean;
-                    }, import("zod/v4/core").$strict>;
-                    readonly static: true;
-                    readonly inheritance: "default";
-                }>;
-                whoami: builder.Function<{
-                    readonly description: "Return the Identity authenticated for this invocation.";
-                    readonly auth: "authenticated";
-                    readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
-                    readonly output: import("zod").ZodObject<{
-                        id: import("zod").ZodString;
-                        issuer: import("zod").ZodString;
-                        subject: import("zod").ZodString;
-                        frozen: import("zod").ZodBoolean;
-                        requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                            claim: import("zod").ZodString;
-                            op: import("zod").ZodLiteral<"contains">;
-                            value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                            claim: import("zod").ZodString;
-                            op: import("zod").ZodLiteral<"eq">;
-                            value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                            claim: import("zod").ZodString;
-                            op: import("zod").ZodLiteral<"exists">;
-                        }, import("zod/v4/core").$strict>], "op">>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly static: true;
-                    readonly inheritance: "default";
-                }>;
-                whois: builder.Function<{
-                    readonly description: "Resolve one issuer-and-subject Identity.";
-                    readonly auth: "authorized";
-                    readonly input: import("zod").ZodObject<{
-                        issuer: import("zod").ZodString;
-                        subject: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: import("zod").ZodNullable<import("zod").ZodObject<{
-                        id: import("zod").ZodString;
-                        issuer: import("zod").ZodString;
-                        subject: import("zod").ZodString;
-                        frozen: import("zod").ZodBoolean;
-                        requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                            claim: import("zod").ZodString;
-                            op: import("zod").ZodLiteral<"contains">;
-                            value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                            claim: import("zod").ZodString;
-                            op: import("zod").ZodLiteral<"eq">;
-                            value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                            claim: import("zod").ZodString;
-                            op: import("zod").ZodLiteral<"exists">;
-                        }, import("zod/v4/core").$strict>], "op">>;
-                    }, import("zod/v4/core").$strict>>;
-                    readonly static: true;
-                    readonly inheritance: "default";
-                }>;
-                mint: builder.Function<{
-                    readonly description: "Resolve and sign one authorized Grant credential.";
-                    readonly auth: "authorized";
-                    readonly input: import("zod").ZodObject<{
-                        audience: import("zod").ZodOptional<import("zod").ZodString>;
-                        ttlSeconds: import("zod").ZodNumber;
-                        grant: import("zod").ZodOptional<import("zod").ZodUnknown>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: import("zod").ZodString;
-                    readonly static: true;
-                    readonly inheritance: "default";
-                }>;
-            }>;
-        }>];
-        readonly properties: {
-            readonly origin: {
-                readonly type: "string";
-                readonly pattern: "[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+";
-            };
-            readonly dependencyContext: builder.Property<{
-                readonly type: "array";
-                readonly items: {
-                    readonly type: "object";
-                };
-            }, {
-                readonly visibility: "private";
-                readonly required: false;
-            }>;
-            readonly schema: builder.Property<{
-                readonly type: "object";
-            }, {
-                readonly visibility: "private";
-            }>;
-            readonly schemaRevision: builder.Property<{
-                readonly type: "string";
-                readonly pattern: "sha256:[0-9a-f]{64}";
-            }, {
-                readonly visibility: "private";
-            }>;
+        readonly target: {
+            readonly as: "target";
+            readonly incoming: "0..*";
         };
-    }>, builder.NodeClass<{
-        readonly description: "The installed graph projection of a both-, Node-, or Edge-family Interface.";
-        readonly implements: readonly [builder.Interface<{
-            readonly family: "both";
-            readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
-            readonly properties: {
-                description: builder.Property<Readonly<{
-                    readonly type: 'string';
-                    readonly minLength: 1;
-                    readonly maxLength: 1000;
-                }>, {
-                    readonly required: false;
-                }>;
-            };
-        }>];
-        readonly properties: {
-            readonly family: {
-                readonly enum: readonly ["both", "node", "edge"];
-            };
-        };
-    }>];
-    readonly incoming: "0..*";
-}, Omit<{
+        readonly constraints: Record<never, never>;
+    }, never, never, never>];
+    readonly properties: never;
     readonly source: {
         readonly as: "view";
-        readonly accepts: readonly [builder.NodeClass<{
-            readonly description: "The installed projection of a declarative browser surface; it is not a principal.";
-            readonly implements: readonly [builder.NodeInterface<{
-                readonly description: "Ordinary projection-node contract for a declarative browser surface.";
-                readonly extends: readonly [builder.Interface<{
-                    readonly family: "both";
-                    readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
-                    readonly properties: {
-                        description: builder.Property<Readonly<{
-                            readonly type: 'string';
-                            readonly minLength: 1;
-                            readonly maxLength: 1000;
-                        }>, {
-                            readonly required: false;
-                        }>;
-                    };
-                }>];
-            }>];
-            readonly methods: Readonly<{
-                resolve: builder.Function<{
-                    readonly description: "Resolve the installed View declarations applicable to one authorized graph target.";
-                    readonly auth: "authorized";
-                    readonly input: import("zod").ZodObject<{
-                        target: import("zod").ZodString;
-                    }, import("zod/v4/core").$strict>;
-                    readonly output: import("zod").ZodObject<{
-                        snapshot: import("zod").ZodString;
-                        views: import("zod").ZodArray<import("zod").ZodObject<{
-                            key: import("zod").ZodString;
-                            declaration: import("zod").ZodObject<{
-                                description: import("zod").ZodOptional<import("zod").ZodString>;
-                                target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                    kind: import("zod").ZodLiteral<"domain">;
-                                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                    kind: import("zod").ZodLiteral<"definition">;
-                                    definitions: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                        origin: import("zod").ZodString;
-                                        kind: import("zod").ZodLiteral<"class">;
-                                        name: import("zod").ZodString;
-                                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                        origin: import("zod").ZodString;
-                                        kind: import("zod").ZodLiteral<"interface">;
-                                        name: import("zod").ZodString;
-                                    }, import("zod/v4/core").$strict>], "kind">>;
-                                }, import("zod/v4/core").$strict>], "kind">;
-                            }, import("zod/v4/core").$strict>;
-                            href: import("zod").ZodString;
-                            handshake: import("zod").ZodEnum<{
-                                none: "none";
-                                shell: "shell";
-                            }>;
-                            issuer: import("zod").ZodString;
-                            etag: import("zod").ZodString;
-                            revision: import("zod").ZodString;
-                        }, import("zod/v4/core").$strict>>;
-                    }, import("zod/v4/core").$strict>;
-                    readonly static: true;
-                    readonly inheritance: "sealed";
-                }>;
-            }>;
-        }>];
         readonly outgoing: "1..*";
     };
     readonly target: {
         readonly as: "target";
-        readonly accepts: readonly [builder.NodeClass<{
-            readonly description: "The installed graph projection of a concrete Node Class or Edge Class declaration.";
-            readonly implements: readonly [builder.Interface<{
-                readonly family: "both";
-                readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
-                readonly properties: {
-                    description: builder.Property<Readonly<{
-                        readonly type: 'string';
-                        readonly minLength: 1;
-                        readonly maxLength: 1000;
-                    }>, {
-                        readonly required: false;
-                    }>;
-                };
-            }>, builder.Interface<{
-                readonly family: "both";
-                readonly description: "Optional bounded presentation icon metadata.";
-                readonly properties: {
-                    icon: builder.Property<Readonly<{
-                        readonly type: 'string';
-                        readonly minLength: 1;
-                        readonly maxLength: 8000;
-                    }>, {
-                        readonly required: false;
-                    }>;
-                };
-            }>];
-            readonly properties: {
-                readonly family: {
-                    readonly enum: readonly ["node", "edge"];
-                };
-            };
-        }>, builder.NodeClass<{
-            readonly description: "A stable Domain principal and the active projection of one canonical DomainSchema revision.";
-            readonly implements: readonly [builder.NodeInterface<{
-                readonly description: "A principal that can be authenticated and can originate persistent authority facts.";
-                readonly properties: {
-                    readonly frozen: builder.Property<{
-                        readonly type: "boolean";
-                    }, {
-                        readonly required: false;
-                        readonly visibility: "private";
-                    }>;
-                    readonly iss: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly requiredClaims: builder.Property<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"contains">;
-                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"eq">;
-                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"exists">;
-                    }, import("zod/v4/core").$strict>], "op">>, {
-                        readonly required: false;
-                        readonly visibility: "private";
-                    }>;
-                    readonly sub: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                };
-                readonly methods: Readonly<{
-                    delegate: builder.Function<{
-                        readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
-                        readonly auth: "authenticated";
-                        readonly input: import("zod").ZodObject<{
-                            audience: import("zod").ZodString;
-                            ttlSeconds: import("zod").ZodNumber;
-                            attenuation: import("zod").ZodUnknown;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodString;
-                        readonly inheritance: "default";
-                    }>;
-                    can: builder.Function<{
-                        readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
-                        readonly auth: "authenticated";
-                        readonly input: import("zod").ZodObject<{
-                            policy: import("zod").ZodString;
-                            object: import("zod").ZodString;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodObject<{
-                            allowed: import("zod").ZodBoolean;
-                        }, import("zod/v4/core").$strict>;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                    whoami: builder.Function<{
-                        readonly description: "Return the Identity authenticated for this invocation.";
-                        readonly auth: "authenticated";
-                        readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodObject<{
-                            id: import("zod").ZodString;
-                            issuer: import("zod").ZodString;
-                            subject: import("zod").ZodString;
-                            frozen: import("zod").ZodBoolean;
-                            requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"contains">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"eq">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"exists">;
-                            }, import("zod/v4/core").$strict>], "op">>;
-                        }, import("zod/v4/core").$strict>;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                    whois: builder.Function<{
-                        readonly description: "Resolve one issuer-and-subject Identity.";
-                        readonly auth: "authorized";
-                        readonly input: import("zod").ZodObject<{
-                            issuer: import("zod").ZodString;
-                            subject: import("zod").ZodString;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodNullable<import("zod").ZodObject<{
-                            id: import("zod").ZodString;
-                            issuer: import("zod").ZodString;
-                            subject: import("zod").ZodString;
-                            frozen: import("zod").ZodBoolean;
-                            requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"contains">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"eq">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"exists">;
-                            }, import("zod/v4/core").$strict>], "op">>;
-                        }, import("zod/v4/core").$strict>>;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                    mint: builder.Function<{
-                        readonly description: "Resolve and sign one authorized Grant credential.";
-                        readonly auth: "authorized";
-                        readonly input: import("zod").ZodObject<{
-                            audience: import("zod").ZodOptional<import("zod").ZodString>;
-                            ttlSeconds: import("zod").ZodNumber;
-                            grant: import("zod").ZodOptional<import("zod").ZodUnknown>;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodString;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                }>;
-            }>];
-            readonly properties: {
-                readonly origin: {
-                    readonly type: "string";
-                    readonly pattern: "[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+";
-                };
-                readonly dependencyContext: builder.Property<{
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "object";
-                    };
-                }, {
-                    readonly visibility: "private";
-                    readonly required: false;
-                }>;
-                readonly schema: builder.Property<{
-                    readonly type: "object";
-                }, {
-                    readonly visibility: "private";
-                }>;
-                readonly schemaRevision: builder.Property<{
-                    readonly type: "string";
-                    readonly pattern: "sha256:[0-9a-f]{64}";
-                }, {
-                    readonly visibility: "private";
-                }>;
-            };
-        }>, builder.NodeClass<{
-            readonly description: "The installed graph projection of a both-, Node-, or Edge-family Interface.";
-            readonly implements: readonly [builder.Interface<{
-                readonly family: "both";
-                readonly description: "Optional human-facing description metadata with no identity or authority semantics.";
-                readonly properties: {
-                    description: builder.Property<Readonly<{
-                        readonly type: 'string';
-                        readonly minLength: 1;
-                        readonly maxLength: 1000;
-                    }>, {
-                        readonly required: false;
-                    }>;
-                };
-            }>];
-            readonly properties: {
-                readonly family: {
-                    readonly enum: readonly ["both", "node", "edge"];
-                };
-            };
-        }>];
         readonly incoming: "0..*";
     };
-    readonly description: "A View declaration targets one Domain or a non-empty set of Classes and Interfaces.";
-    readonly implements: readonly [builder.Interface<{
-        readonly family: "both";
-        readonly description: "Explicit kernel marker for Edge definitions; it carries no structural fields.";
-    }>];
-}, "source" | "target">>;
-//# sourceMappingURL=view-for.d.ts.map
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/callables/view-for.js

@@ -1,12 +1,12 @@
 import { edgeClass } from '@astrale-os/kernel-dsl/v1';
-import { Class, Interface } from '../definitions/index.js';
+import { Class } from '../definitions/index.js';
 import { Domain } from '../domain/index.js';
 import { Edge } from '../meta/index.js';
 import { View } from './view.js';
 export const ViewFor = edgeClass.directed({
+    abstract: false,
     source: { as: 'view', accepts: [View], outgoing: '1..*' },
-    target: { as: 'target', accepts: [Class, Domain, Interface], incoming: '0..*' },
-    description: 'A View declaration targets one Domain or a non-empty set of Classes and Interfaces.',
-    implements: [Edge],
+    target: { as: 'target', accepts: [Class, Domain], incoming: '0..*' },
+    description: 'A View declaration targets one Domain or a non-empty set of Classes.',
+    extends: [Edge],
 });
-//# sourceMappingURL=view-for.js.map