@astrale-os/kernel-core 0.4.1

package/dist/schema/classes/Domain.class.d.ts

@@ -0,0 +1,287 @@
+import z from 'zod';
+export declare const Domain: import("@astrale-os/kernel-dsl").NodeClassDef<Omit<{
+    readonly implements: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+        readonly methods: {
+            listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly filters: z.ZodOptional<z.ZodUnknown>;
+            }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+            push: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+            }, z.ZodVoid, "sealed", boolean>;
+        };
+    }, "props"> & {
+        readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                    onConflict: z.ZodOptional<z.ZodEnum<{
+                        defaults: "defaults";
+                        error: "error";
+                        merge: "merge";
+                        replace: "replace";
+                        skip: "skip";
+                    }>>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    name: z.ZodString;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    description: z.ZodOptional<z.ZodString>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    status: z.ZodEnum<{
+                        active: "active";
+                        creating: "creating";
+                        deleting: "deleting";
+                        error: "error";
+                        updating: "updating";
+                    }>;
+                };
+            }>];
+            readonly methods: {
+                init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                update: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.ZodVoid, "default", boolean>;
+                delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                move: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                }, z.ZodVoid, "sealed", boolean>;
+                link: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodVoid, "default", boolean>;
+                unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                }, z.ZodVoid, "default", boolean>;
+                getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                    readonly direction: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        in: "in";
+                        out: "out";
+                    }>>;
+                }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly depth: z.ZodNumber;
+                    readonly maxNodes: z.ZodNumber;
+                }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+            };
+        }>];
+    }>];
+    readonly icon: string;
+    readonly props: {
+        domain: z.ZodCustom<import("#domain/origin").DomainOrigin, import("#domain/origin").DomainOrigin>;
+        /**
+         * Full SchemaIR for this domain, JSON-encoded. Written at serialize time
+         * so deserialization can reconstruct the CompiledDomain from a single
+         * blob read — no walk over Class/Interface/Function nodes required for
+         * types, inheritance, imports, or the IR itself.
+         */
+        schema: z.ZodOptional<z.ZodString>;
+    };
+    readonly methods: {
+        init: import("@astrale-os/kernel-dsl").FnDef<{}, z.ZodVoid, import("@astrale-os/kernel-dsl").MethodInheritance, true>;
+    };
+}, "props"> & {
+    readonly properties: {
+        readonly domain: z.ZodCustom<import("#domain/origin").DomainOrigin, import("#domain/origin").DomainOrigin>;
+        /**
+         * Full SchemaIR for this domain, JSON-encoded. Written at serialize time
+         * so deserialization can reconstruct the CompiledDomain from a single
+         * blob read — no walk over Class/Interface/Function nodes required for
+         * types, inheritance, imports, or the IR itself.
+         */
+        readonly schema: z.ZodOptional<z.ZodString>;
+    };
+} & {
+    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+        readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                createdAt: z.ZodISODateTime;
+                updatedAt: z.ZodISODateTime;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                onConflict: z.ZodOptional<z.ZodEnum<{
+                    defaults: "defaults";
+                    error: "error";
+                    merge: "merge";
+                    replace: "replace";
+                    skip: "skip";
+                }>>;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                name: z.ZodString;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                description: z.ZodOptional<z.ZodString>;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                status: z.ZodEnum<{
+                    active: "active";
+                    creating: "creating";
+                    deleting: "deleting";
+                    error: "error";
+                    updating: "updating";
+                }>;
+            };
+        }>];
+        readonly methods: {
+            init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+            createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+            get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+            update: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.ZodVoid, "default", boolean>;
+            delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+            deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+            move: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+            }, z.ZodVoid, "sealed", boolean>;
+            link: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.ZodVoid, "default", boolean>;
+            unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+            }, z.ZodVoid, "default", boolean>;
+            getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                readonly direction: z.ZodOptional<z.ZodEnum<{
+                    both: "both";
+                    in: "in";
+                    out: "out";
+                }>>;
+            }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+            getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly depth: z.ZodNumber;
+                readonly maxNodes: z.ZodNumber;
+            }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+        };
+    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+        readonly methods: {
+            listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly filters: z.ZodOptional<z.ZodUnknown>;
+            }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+            push: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+            }, z.ZodVoid, "sealed", boolean>;
+        };
+    }, "props"> & {
+        readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                    onConflict: z.ZodOptional<z.ZodEnum<{
+                        defaults: "defaults";
+                        error: "error";
+                        merge: "merge";
+                        replace: "replace";
+                        skip: "skip";
+                    }>>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    name: z.ZodString;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    description: z.ZodOptional<z.ZodString>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    status: z.ZodEnum<{
+                        active: "active";
+                        creating: "creating";
+                        deleting: "deleting";
+                        error: "error";
+                        updating: "updating";
+                    }>;
+                };
+            }>];
+            readonly methods: {
+                init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                update: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.ZodVoid, "default", boolean>;
+                delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                move: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                }, z.ZodVoid, "sealed", boolean>;
+                link: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodVoid, "default", boolean>;
+                unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                }, z.ZodVoid, "default", boolean>;
+                getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                    readonly direction: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        in: "in";
+                        out: "out";
+                    }>>;
+                }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly depth: z.ZodNumber;
+                    readonly maxNodes: z.ZodNumber;
+                }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+            };
+        }>];
+    }>];
+}>;
+//# sourceMappingURL=Domain.class.d.ts.map

package/dist/schema/classes/Domain.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Domain.class.d.ts","sourceRoot":"","sources":["../../../schema/classes/Domain.class.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAQnB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAIf,MAAM;QACN;;;;;WAKG;QACH,MAAM;;;QAGN,IAAI;;;;;QATJ;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUL,CAAA"}

package/dist/schema/classes/Domain.class.js

@@ -0,0 +1,28 @@
+import { fn } from '@astrale-os/kernel-dsl';
+import z from 'zod';
+import { domainOriginSchema } from '#domain/origin';
+import { nodeClass } from '#schema/definitions';
+import { Container } from '#schema/interfaces';
+import { DOMAIN_ICON } from './icons';
+export const Domain = nodeClass({
+    implements: [Container],
+    icon: DOMAIN_ICON,
+    props: {
+        domain: domainOriginSchema,
+        /**
+         * Full SchemaIR for this domain, JSON-encoded. Written at serialize time
+         * so deserialization can reconstruct the CompiledDomain from a single
+         * blob read — no walk over Class/Interface/Function nodes required for
+         * types, inheritance, imports, or the IR itself.
+         */
+        schema: z.string().optional(),
+    },
+    methods: {
+        init: fn({
+            static: true,
+            params: {},
+            returns: z.void(),
+        }),
+    },
+});
+//# sourceMappingURL=Domain.class.js.map

package/dist/schema/classes/Domain.class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Domain.class.js","sourceRoot":"","sources":["../../../schema/classes/Domain.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAA;AAC3C,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAE9C,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAErC,MAAM,CAAC,MAAM,MAAM,GAAG,SAAS,CAAC;IAC9B,UAAU,EAAE,CAAC,SAAS,CAAC;IACvB,IAAI,EAAE,WAAW;IACjB,KAAK,EAAE;QACL,MAAM,EAAE,kBAAkB;QAC1B;;;;;WAKG;QACH,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC9B;IACD,OAAO,EAAE;QACP,IAAI,EAAE,EAAE,CAAC;YACP,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE,EAAE;YACV,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE;SAClB,CAAC;KACH;CACF,CAAC,CAAA"}

package/dist/schema/classes/Folder.class.d.ts

@@ -0,0 +1,269 @@
+import z from 'zod';
+export declare const Folder: import("@astrale-os/kernel-dsl").NodeClassDef<Omit<{
+    readonly implements: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+        readonly methods: {
+            listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly filters: z.ZodOptional<z.ZodUnknown>;
+            }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+            push: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+            }, z.ZodVoid, "sealed", boolean>;
+        };
+    }, "props"> & {
+        readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                    onConflict: z.ZodOptional<z.ZodEnum<{
+                        defaults: "defaults";
+                        error: "error";
+                        merge: "merge";
+                        replace: "replace";
+                        skip: "skip";
+                    }>>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    name: z.ZodString;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    description: z.ZodOptional<z.ZodString>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    status: z.ZodEnum<{
+                        active: "active";
+                        creating: "creating";
+                        deleting: "deleting";
+                        error: "error";
+                        updating: "updating";
+                    }>;
+                };
+            }>];
+            readonly methods: {
+                init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                update: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.ZodVoid, "default", boolean>;
+                delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                move: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                }, z.ZodVoid, "sealed", boolean>;
+                link: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodVoid, "default", boolean>;
+                unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                }, z.ZodVoid, "default", boolean>;
+                getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                    readonly direction: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        in: "in";
+                        out: "out";
+                    }>>;
+                }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly depth: z.ZodNumber;
+                    readonly maxNodes: z.ZodNumber;
+                }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+            };
+        }>];
+    }>];
+    readonly icon: string;
+    readonly methods: {
+        init: import("@astrale-os/kernel-dsl").FnDef<{
+            readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+            readonly name: z.ZodString;
+        }, z.ZodVoid, import("@astrale-os/kernel-dsl").MethodInheritance, true>;
+    };
+}, "props"> & {
+    readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+        readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                createdAt: z.ZodISODateTime;
+                updatedAt: z.ZodISODateTime;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                onConflict: z.ZodOptional<z.ZodEnum<{
+                    defaults: "defaults";
+                    error: "error";
+                    merge: "merge";
+                    replace: "replace";
+                    skip: "skip";
+                }>>;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                name: z.ZodString;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                description: z.ZodOptional<z.ZodString>;
+            };
+        }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly properties: {
+                status: z.ZodEnum<{
+                    active: "active";
+                    creating: "creating";
+                    deleting: "deleting";
+                    error: "error";
+                    updating: "updating";
+                }>;
+            };
+        }>];
+        readonly methods: {
+            init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+            createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+            get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+            update: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.ZodVoid, "default", boolean>;
+            delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+            deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+            move: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+            }, z.ZodVoid, "sealed", boolean>;
+            link: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.ZodVoid, "default", boolean>;
+            unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+            }, z.ZodVoid, "default", boolean>;
+            getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                readonly direction: z.ZodOptional<z.ZodEnum<{
+                    both: "both";
+                    in: "in";
+                    out: "out";
+                }>>;
+            }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+            getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly depth: z.ZodNumber;
+                readonly maxNodes: z.ZodNumber;
+            }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+        };
+    }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<Omit<{
+        readonly methods: {
+            listChildren: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly filters: z.ZodOptional<z.ZodUnknown>;
+            }, z.ZodArray<z.ZodCustom<import("../..").Node, import("../..").Node>>, "sealed", boolean>;
+            push: import("@astrale-os/kernel-dsl").FnDef<{
+                readonly patch: z.ZodCustom<import("../..").Patch, import("../..").Patch>;
+                readonly root: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+            }, z.ZodVoid, "sealed", boolean>;
+        };
+    }, "props"> & {
+        readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+            readonly inherits: readonly [import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    externalId: z.ZodOptional<z.ZodCustom<import("../..").ExternalId, import("../..").ExternalId>>;
+                    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+                    onConflict: z.ZodOptional<z.ZodEnum<{
+                        defaults: "defaults";
+                        error: "error";
+                        merge: "merge";
+                        replace: "replace";
+                        skip: "skip";
+                    }>>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    name: z.ZodString;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    description: z.ZodOptional<z.ZodString>;
+                };
+            }>, import("@astrale-os/kernel-dsl").NodeInterfaceDef<{
+                readonly properties: {
+                    status: z.ZodEnum<{
+                        active: "active";
+                        creating: "creating";
+                        deleting: "deleting";
+                        error: "error";
+                        updating: "updating";
+                    }>;
+                };
+            }>];
+            readonly methods: {
+                init: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", true>;
+                createNode: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly path: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", true>;
+                get: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodCustom<import("../..").Node, import("../..").Node>, "sealed", boolean>;
+                update: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.ZodVoid, "default", boolean>;
+                delete: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodVoid, "default", boolean>;
+                deleteNode: import("@astrale-os/kernel-dsl").FnDef<import("@astrale-os/kernel-dsl").ParamShape, z.ZodNull, "sealed", boolean>;
+                move: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly to: z.ZodType<import("../..").AbsolutePath, string | import("../..").AbsolutePath, z.core.$ZodTypeInternals<import("../..").AbsolutePath, string | import("../..").AbsolutePath>>;
+                }, z.ZodVoid, "sealed", boolean>;
+                link: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                    readonly props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.ZodVoid, "default", boolean>;
+                unlink: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClass: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+                    readonly target: z.ZodType<import("../..").Path, string | import("../..").Path, z.core.$ZodTypeInternals<import("../..").Path, string | import("../..").Path>>;
+                    readonly slug: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Slug, string>>>;
+                }, z.ZodVoid, "default", boolean>;
+                getLinks: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly edgeClasses: z.ZodOptional<z.ZodArray<z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>>>;
+                    readonly direction: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        in: "in";
+                        out: "out";
+                    }>>;
+                }, z.ZodCustom<import("../..").Edge[], import("../..").Edge[]>, "sealed", boolean>;
+                getTree: import("@astrale-os/kernel-dsl").FnDef<{
+                    readonly depth: z.ZodNumber;
+                    readonly maxNodes: z.ZodNumber;
+                }, z.ZodCustom<import("../..").GraphData, import("../..").GraphData>, "sealed", boolean>;
+            };
+        }>];
+    }>];
+}>;
+//# sourceMappingURL=Folder.class.d.ts.map

package/dist/schema/classes/Folder.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Folder.class.d.ts","sourceRoot":"","sources":["../../../schema/classes/Folder.class.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAQnB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAIf,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASN,CAAA"}

package/dist/schema/classes/Folder.class.js

@@ -0,0 +1,21 @@
+import { fn } from '@astrale-os/kernel-dsl';
+import z from 'zod';
+import { absolutePathSchema } from '#graph/tree/zod';
+import { nodeClass } from '#schema/definitions';
+import { Container } from '#schema/interfaces';
+import { FOLDER_ICON } from './icons';
+export const Folder = nodeClass({
+    implements: [Container],
+    icon: FOLDER_ICON,
+    methods: {
+        init: fn({
+            static: true,
+            params: {
+                path: absolutePathSchema(),
+                name: z.string().min(1).max(100),
+            },
+            returns: z.void(),
+        }),
+    },
+});
+//# sourceMappingURL=Folder.class.js.map