@vitnode/core 1.2.0-canary.10

package/dist/src/components/ui/table.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../../lib/utils";
+function Table({ className, ...props }) {
+    return /*#__PURE__*/ _jsx("div", {
+        className: "relative w-full overflow-x-auto",
+        "data-slot": "table-container",
+        children: /*#__PURE__*/ _jsx("table", {
+            className: cn('w-full caption-bottom text-sm', className),
+            "data-slot": "table",
+            ...props
+        })
+    });
+}
+function TableHeader({ className, ...props }) {
+    return /*#__PURE__*/ _jsx("thead", {
+        className: cn('[&_tr]:border-b', className),
+        "data-slot": "table-header",
+        ...props
+    });
+}
+function TableBody({ className, ...props }) {
+    return /*#__PURE__*/ _jsx("tbody", {
+        className: cn('bg-card [&_tr:last-child]:border-0', className),
+        "data-slot": "table-body",
+        ...props
+    });
+}
+function TableFooter({ className, ...props }) {
+    return /*#__PURE__*/ _jsx("tfoot", {
+        className: cn('bg-muted/50 border-t font-medium [&>tr]:last:border-b-0', className),
+        "data-slot": "table-footer",
+        ...props
+    });
+}
+function TableRow({ className, ...props }) {
+    return /*#__PURE__*/ _jsx("tr", {
+        className: cn('hover:bg-muted/50 data-[state=selected]:bg-muted border-b transition-colors', className),
+        "data-slot": "table-row",
+        ...props
+    });
+}
+function TableHead({ className, ...props }) {
+    return /*#__PURE__*/ _jsx("th", {
+        className: cn('text-foreground h-10 whitespace-nowrap px-2 text-left align-middle font-medium [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]', className),
+        "data-slot": "table-head",
+        ...props
+    });
+}
+function TableCell({ className, ...props }) {
+    return /*#__PURE__*/ _jsx("td", {
+        className: cn('whitespace-nowrap p-2 align-middle [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]', className),
+        "data-slot": "table-cell",
+        ...props
+    });
+}
+function TableCaption({ className, ...props }) {
+    return /*#__PURE__*/ _jsx("caption", {
+        className: cn('text-muted-foreground mt-4 text-sm', className),
+        "data-slot": "table-caption",
+        ...props
+    });
+}
+export { Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow };

package/dist/src/components/ui/tabs.d.ts

@@ -0,0 +1,8 @@
+import { Tabs as TabsPrimitive } from 'radix-ui';
+import * as React from 'react';
+declare function Tabs({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TabsList({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.List>): import("react/jsx-runtime").JSX.Element;
+declare function TabsTrigger({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TabsContent({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tabs, TabsContent, TabsList, TabsTrigger };
+//# sourceMappingURL=tabs.d.ts.map

package/dist/src/components/ui/tabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabs.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/tabs.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,IAAI,aAAa,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,iBAAS,IAAI,CAAC,EACZ,SAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,aAAa,CAAC,IAAI,CAAC,2CAQjD;AAED,iBAAS,QAAQ,CAAC,EAChB,SAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,aAAa,CAAC,IAAI,CAAC,2CAWjD;AAED,iBAAS,WAAW,CAAC,EACnB,SAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,aAAa,CAAC,OAAO,CAAC,2CAWpD;AAED,iBAAS,WAAW,CAAC,EACnB,SAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,aAAa,CAAC,OAAO,CAAC,2CAQpD;AAED,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC"}

package/dist/src/components/ui/tabs.js

@@ -0,0 +1,34 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Tabs as TabsPrimitive } from "radix-ui";
+import * as React from "react";
+import { cn } from "../../lib/utils";
+function Tabs({ className, ...props }) {
+    return /*#__PURE__*/ _jsx(TabsPrimitive.Root, {
+        className: cn('flex flex-col gap-2', className),
+        "data-slot": "tabs",
+        ...props
+    });
+}
+function TabsList({ className, ...props }) {
+    return /*#__PURE__*/ _jsx(TabsPrimitive.List, {
+        className: cn('bg-muted text-muted-foreground inline-flex h-9 w-fit items-center justify-center rounded-lg p-[3px]', className),
+        "data-slot": "tabs-list",
+        ...props
+    });
+}
+function TabsTrigger({ className, ...props }) {
+    return /*#__PURE__*/ _jsx(TabsPrimitive.Trigger, {
+        className: cn("data-[state=active]:bg-background dark:data-[state=active]:text-foreground focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:outline-ring dark:data-[state=active]:border-input dark:data-[state=active]:bg-input/30 text-foreground dark:text-muted-foreground inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center gap-1.5 whitespace-nowrap rounded-md border border-transparent px-2 py-1 text-sm font-medium transition-[color,box-shadow] focus-visible:outline-1 focus-visible:ring-[3px] disabled:pointer-events-none disabled:opacity-50 data-[state=active]:shadow-sm [&_svg:not([class*='size-'])]:size-4 [&_svg]:pointer-events-none [&_svg]:shrink-0", className),
+        "data-slot": "tabs-trigger",
+        ...props
+    });
+}
+function TabsContent({ className, ...props }) {
+    return /*#__PURE__*/ _jsx(TabsPrimitive.Content, {
+        className: cn('flex-1 outline-none', className),
+        "data-slot": "tabs-content",
+        ...props
+    });
+}
+export { Tabs, TabsContent, TabsList, TabsTrigger };

package/dist/src/components/ui/textarea.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+declare function Textarea({ className, ...props }: React.ComponentProps<'textarea'>): import("react/jsx-runtime").JSX.Element;
+export { Textarea };
+//# sourceMappingURL=textarea.d.ts.map

package/dist/src/components/ui/textarea.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textarea.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/textarea.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,iBAAS,QAAQ,CAAC,EAAE,SAAS,EAAE,GAAG,KAAK,EAAE,EAAE,KAAK,CAAC,cAAc,CAAC,UAAU,CAAC,2CAW1E;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/src/components/ui/textarea.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../../lib/utils";
+function Textarea({ className, ...props }) {
+    return /*#__PURE__*/ _jsx("textarea", {
+        className: cn('border-input placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:bg-input/30 field-sizing-content shadow-xs flex min-h-16 w-full rounded-md border bg-transparent px-3 py-2 text-base outline-none transition-[color,box-shadow] focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 md:text-sm', className),
+        "data-slot": "textarea",
+        ...props
+    });
+}
+export { Textarea };

package/dist/src/components/ui/toggle-group.d.ts

@@ -0,0 +1,8 @@
+import { type VariantProps } from 'class-variance-authority';
+import { ToggleGroup as ToggleGroupPrimitive } from 'radix-ui';
+import * as React from 'react';
+import { toggleVariants } from '../../components/ui/toggle';
+declare function ToggleGroup({ className, variant, size, children, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Root> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
+declare function ToggleGroupItem({ className, children, variant, size, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Item> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
+export { ToggleGroup, ToggleGroupItem };
+//# sourceMappingURL=toggle-group.d.ts.map

package/dist/src/components/ui/toggle-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle-group.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/toggle-group.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,WAAW,IAAI,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAUxD,iBAAS,WAAW,CAAC,EACnB,SAAS,EACT,OAAO,EACP,IAAI,EACJ,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,IAAI,CAAC,GACvD,YAAY,CAAC,OAAO,cAAc,CAAC,2CAiBpC;AAED,iBAAS,eAAe,CAAC,EACvB,SAAS,EACT,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,IAAI,CAAC,GACvD,YAAY,CAAC,OAAO,cAAc,CAAC,2CAqBpC;AAED,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,CAAC"}

package/dist/src/components/ui/toggle-group.js

@@ -0,0 +1,41 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ToggleGroup as ToggleGroupPrimitive } from "radix-ui";
+import * as React from "react";
+import { toggleVariants } from "./toggle";
+import { cn } from "../../lib/utils";
+const ToggleGroupContext = /*#__PURE__*/ React.createContext({
+    size: 'default',
+    variant: 'default'
+});
+function ToggleGroup({ className, variant, size, children, ...props }) {
+    return /*#__PURE__*/ _jsx(ToggleGroupPrimitive.Root, {
+        className: cn('group/toggle-group data-[variant=outline]:shadow-xs flex w-fit items-center rounded-md', className),
+        "data-size": size,
+        "data-slot": "toggle-group",
+        "data-variant": variant,
+        ...props,
+        children: /*#__PURE__*/ _jsx(ToggleGroupContext.Provider, {
+            value: {
+                variant,
+                size
+            },
+            children: children
+        })
+    });
+}
+function ToggleGroupItem({ className, children, variant, size, ...props }) {
+    const context = React.useContext(ToggleGroupContext);
+    return /*#__PURE__*/ _jsx(ToggleGroupPrimitive.Item, {
+        className: cn(toggleVariants({
+            variant: context.variant ?? variant,
+            size: context.size ?? size
+        }), 'min-w-0 flex-1 shrink-0 rounded-none shadow-none first:rounded-l-md last:rounded-r-md focus:z-10 focus-visible:z-10 data-[variant=outline]:border-l-0 data-[variant=outline]:first:border-l', className),
+        "data-size": context.size ?? size,
+        "data-slot": "toggle-group-item",
+        "data-variant": context.variant ?? variant,
+        ...props,
+        children: children
+    });
+}
+export { ToggleGroup, ToggleGroupItem };

package/dist/src/components/ui/toggle.d.ts

@@ -0,0 +1,10 @@
+import { type VariantProps } from 'class-variance-authority';
+import { Toggle as TogglePrimitive } from 'radix-ui';
+import * as React from 'react';
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Toggle({ className, variant, size, ...props }: React.ComponentProps<typeof TogglePrimitive.Root> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
+export { Toggle, toggleVariants };
+//# sourceMappingURL=toggle.d.ts.map

package/dist/src/components/ui/toggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/toggle.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,MAAM,IAAI,eAAe,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,QAAA,MAAM,cAAc;;;8EAoBnB,CAAC;AAEF,iBAAS,MAAM,CAAC,EACd,SAAS,EACT,OAAO,EACP,IAAI,EACJ,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,eAAe,CAAC,IAAI,CAAC,GAClD,YAAY,CAAC,OAAO,cAAc,CAAC,2CAQpC;AAED,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC"}

package/dist/src/components/ui/toggle.js

@@ -0,0 +1,35 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { Toggle as TogglePrimitive } from "radix-ui";
+import * as React from "react";
+import { cn } from "../../lib/utils";
+const toggleVariants = cva("inline-flex items-center justify-center gap-2 rounded-md text-sm font-medium hover:bg-muted hover:text-muted-foreground disabled:pointer-events-none disabled:opacity-50 data-[state=on]:bg-accent data-[state=on]:text-accent-foreground [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 [&_svg]:shrink-0 focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] outline-none transition-[color,box-shadow] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive whitespace-nowrap", {
+    variants: {
+        variant: {
+            default: 'bg-transparent',
+            outline: 'border border-input bg-transparent shadow-xs hover:bg-accent hover:text-accent-foreground'
+        },
+        size: {
+            default: 'h-9 px-2 min-w-9',
+            sm: 'h-8 px-1.5 min-w-8',
+            lg: 'h-10 px-2.5 min-w-10'
+        }
+    },
+    defaultVariants: {
+        variant: 'default',
+        size: 'default'
+    }
+});
+function Toggle({ className, variant, size, ...props }) {
+    return /*#__PURE__*/ _jsx(TogglePrimitive.Root, {
+        className: cn(toggleVariants({
+            variant,
+            size,
+            className
+        })),
+        "data-slot": "toggle",
+        ...props
+    });
+}
+export { Toggle, toggleVariants };

package/dist/src/components/ui/tooltip.d.ts

@@ -0,0 +1,8 @@
+import { Tooltip as TooltipPrimitive } from 'radix-ui';
+import * as React from 'react';
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };
+//# sourceMappingURL=tooltip.d.ts.map

package/dist/src/components/ui/tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/tooltip.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,iBAAS,eAAe,CAAC,EACvB,aAAiB,EACjB,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,gBAAgB,CAAC,QAAQ,CAAC,2CAQxD;AAED,iBAAS,OAAO,CAAC,EACf,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,gBAAgB,CAAC,IAAI,CAAC,2CAMpD;AAED,iBAAS,cAAc,CAAC,EACtB,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,gBAAgB,CAAC,OAAO,CAAC,2CAEvD;AAED,iBAAS,cAAc,CAAC,EACtB,SAAS,EACT,UAAc,EACd,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,gBAAgB,CAAC,OAAO,CAAC,2CAiBvD;AAED,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,cAAc,EAAE,CAAC"}

package/dist/src/components/ui/tooltip.js

@@ -0,0 +1,43 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Tooltip as TooltipPrimitive } from "radix-ui";
+import * as React from "react";
+import { cn } from "../../lib/utils";
+function TooltipProvider({ delayDuration = 0, ...props }) {
+    return /*#__PURE__*/ _jsx(TooltipPrimitive.Provider, {
+        "data-slot": "tooltip-provider",
+        delayDuration: delayDuration,
+        ...props
+    });
+}
+function Tooltip({ ...props }) {
+    return /*#__PURE__*/ _jsx(TooltipProvider, {
+        children: /*#__PURE__*/ _jsx(TooltipPrimitive.Root, {
+            "data-slot": "tooltip",
+            ...props
+        })
+    });
+}
+function TooltipTrigger({ ...props }) {
+    return /*#__PURE__*/ _jsx(TooltipPrimitive.Trigger, {
+        "data-slot": "tooltip-trigger",
+        ...props
+    });
+}
+function TooltipContent({ className, sideOffset = 0, children, ...props }) {
+    return /*#__PURE__*/ _jsx(TooltipPrimitive.Portal, {
+        children: /*#__PURE__*/ _jsxs(TooltipPrimitive.Content, {
+            className: cn('bg-primary text-primary-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-(--radix-tooltip-content-transform-origin) z-50 w-fit text-balance rounded-md px-3 py-1.5 text-xs', className),
+            "data-slot": "tooltip-content",
+            sideOffset: sideOffset,
+            ...props,
+            children: [
+                children,
+                /*#__PURE__*/ _jsx(TooltipPrimitive.Arrow, {
+                    className: "bg-primary fill-primary z-50 size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px]"
+                })
+            ]
+        })
+    });
+}
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

package/dist/src/components/ui/unsaved-changes-dialog.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=unsaved-changes-dialog.d.ts.map

package/dist/src/components/ui/unsaved-changes-dialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsaved-changes-dialog.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/unsaved-changes-dialog.tsx"],"names":[],"mappings":""}

package/dist/src/config.d.ts

@@ -0,0 +1,5 @@
+export declare const CONFIG_PLUGIN: {
+    pluginId: "@vitnode/core";
+    version: string;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/src/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa;;;CAGzB,CAAC"}

package/dist/src/config.js

@@ -0,0 +1,4 @@
+export const CONFIG_PLUGIN = {
+    pluginId: '@vitnode/core',
+    version: '2.0.0-canary.0'
+};

package/dist/src/database/admins.d.ts

@@ -0,0 +1,246 @@
+export declare const core_admin_permissions: Omit<import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "core_admin_permissions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "core_admin_permissions";
+            dataType: "number";
+            columnType: "PgSerial";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        roleId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "roleId";
+            tableName: "core_admin_permissions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "userId";
+            tableName: "core_admin_permissions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "core_admin_permissions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updatedAt";
+            tableName: "core_admin_permissions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        protected: import("drizzle-orm/pg-core").PgColumn<{
+            name: "protected";
+            tableName: "core_admin_permissions";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>, "enableRLS">;
+export declare const core_admin_permissions_relations: import("drizzle-orm").Relations<"core_admin_permissions", {
+    group: import("drizzle-orm").One<"core_roles", false>;
+    user: import("drizzle-orm").One<"core_users", false>;
+}>;
+export declare const core_admin_sessions: Omit<import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "core_admin_sessions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "core_admin_sessions";
+            dataType: "number";
+            columnType: "PgSerial";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        token: import("drizzle-orm/pg-core").PgColumn<{
+            name: "token";
+            tableName: "core_admin_sessions";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "userId";
+            tableName: "core_admin_sessions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "core_admin_sessions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastSeen: import("drizzle-orm/pg-core").PgColumn<{
+            name: "lastSeen";
+            tableName: "core_admin_sessions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expiresAt";
+            tableName: "core_admin_sessions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        deviceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "deviceId";
+            tableName: "core_admin_sessions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>, "enableRLS">;
+export declare const core_admin_sessions_relations: import("drizzle-orm").Relations<"core_admin_sessions", {
+    user: import("drizzle-orm").One<"core_users", true>;
+    device: import("drizzle-orm").One<"core_sessions_known_devices", true>;
+}>;
+//# sourceMappingURL=admins.d.ts.map

package/dist/src/database/admins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admins.d.ts","sourceRoot":"","sources":["../../../src/database/admins.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwBtB,CAAC;AAEd,eAAO,MAAM,gCAAgC;;;EAY5C,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAyBnB,CAAC;AAEd,eAAO,MAAM,6BAA6B;;;EAYzC,CAAC"}

package/dist/src/database/admins.js

@@ -0,0 +1,74 @@
+import { relations } from "drizzle-orm";
+import { index, pgTable } from "drizzle-orm/pg-core";
+import { core_roles } from "./roles";
+import { core_sessions_known_devices } from "./sessions";
+import { core_users } from "./users";
+export const core_admin_permissions = pgTable('core_admin_permissions', (t)=>({
+        id: t.serial().primaryKey(),
+        roleId: t.integer().references(()=>core_roles.id, {
+            onDelete: 'cascade'
+        }),
+        userId: t.integer().references(()=>core_users.id, {
+            onDelete: 'cascade'
+        }),
+        createdAt: t.timestamp().notNull().defaultNow(),
+        updatedAt: t.timestamp().notNull().$onUpdate(()=>new Date()),
+        protected: t.boolean().notNull().default(false)
+    }), (t)=>[
+        index('core_admin_permissions_role_id_idx').on(t.roleId),
+        index('core_admin_permissions_user_id_idx').on(t.userId)
+    ]).enableRLS();
+export const core_admin_permissions_relations = relations(core_admin_permissions, ({ one })=>({
+        group: one(core_roles, {
+            fields: [
+                core_admin_permissions.roleId
+            ],
+            references: [
+                core_roles.id
+            ]
+        }),
+        user: one(core_users, {
+            fields: [
+                core_admin_permissions.userId
+            ],
+            references: [
+                core_users.id
+            ]
+        })
+    }));
+export const core_admin_sessions = pgTable('core_admin_sessions', (t)=>({
+        id: t.serial().primaryKey(),
+        token: t.varchar({
+            length: 255
+        }).notNull().unique(),
+        userId: t.integer().notNull().references(()=>core_users.id, {
+            onDelete: 'cascade'
+        }),
+        createdAt: t.timestamp().notNull().defaultNow(),
+        lastSeen: t.timestamp().notNull().defaultNow(),
+        expiresAt: t.timestamp().notNull(),
+        deviceId: t.integer().references(()=>core_sessions_known_devices.id, {
+            onDelete: 'cascade'
+        }).notNull()
+    }), (t)=>[
+        index('core_admin_sessions_token_idx').on(t.token),
+        index('core_admin_sessions_user_id_idx').on(t.userId)
+    ]).enableRLS();
+export const core_admin_sessions_relations = relations(core_admin_sessions, ({ one })=>({
+        user: one(core_users, {
+            fields: [
+                core_admin_sessions.userId
+            ],
+            references: [
+                core_users.id
+            ]
+        }),
+        device: one(core_sessions_known_devices, {
+            fields: [
+                core_admin_sessions.deviceId
+            ],
+            references: [
+                core_sessions_known_devices.id
+            ]
+        })
+    }));