@modufolio/panel 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Maarten Thiebou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,165 @@
+# @modufolio/panel
+
+Schema-driven admin panel components for Inertia.js + Vue 3 — tables,
+blueprint forms, filters, actions, drawers, widgets. Tables can be driven
+entirely by a server-authored schema. The frontend companion
+to [modufolio/appkit](https://github.com/modufolio/appkit), usable with any
+Inertia-speaking backend.
+
+> **Status: 0.x pre-release.** APIs may move between minors; the barrel
+> export list (`src/index.ts`) is the public API surface.
+
+## Install
+
+```bash
+npm install @modufolio/panel
+```
+
+Peer dependencies: `vue ^3.5`, `@inertiajs/vue3 ^3`, `@heroicons/vue ^2`,
+and (optional) `@vueuse/core`, `vuedraggable`, `lodash`.
+
+## Setup
+
+One plugin call configures everything:
+
+```js
+import { createPanel } from '@modufolio/panel'
+
+createApp({ render: () => h(App, props) })
+  .use(createPanel({
+    baseUrl: '/panel',                       // your backend mount path
+    icons: { camera: CameraIcon },           // extend/override <Icon> names
+    fields: {                                // app-specific blueprint fields
+      'block-editor': () => import('./Fields/BlockEditorField.vue'),
+    },
+  }))
+  .mount(el)
+```
+
+Every URL the panel builds goes through `panelUrl()` with that `baseUrl` —
+nothing in the package hardcodes a mount path (CI-enforced).
+
+## Styles (Tailwind CSS 4)
+
+The package ships source `.vue` files and source CSS — your Tailwind build
+compiles both. In your CSS entry:
+
+```css
+@import 'tailwindcss';
+@import '@modufolio/panel/styles' layer(components);
+@source "../node_modules/@modufolio/panel";
+```
+
+Theming: components use the semantic `--color-primary-*` / `success` /
+`danger` / `warning` / `info` scales. Import
+`@modufolio/panel/styles/tokens.css` for the defaults, then override any
+value in your own `@theme` block to re-brand.
+
+## Quick example
+
+```vue
+<script setup>
+import { Table, BlueprintForm, Drawer, useResource, defineColumn, panelUrl } from '@modufolio/panel'
+
+const resource = useResource({
+  endpoint: panelUrl('/api/users'),
+  columns: [
+    defineColumn({ name: 'name', label: 'Name', sortable: true }),
+    defineColumn({ name: 'email', label: 'Email' }),
+  ],
+})
+
+const fields = [
+  { type: 'text', key: 'name', label: 'Name', required: true, width: '1/2' },
+  { type: 'text', key: 'email', label: 'Email', width: '1/2' },
+  { type: 'toggle', key: 'active', label: 'Active', when: f => !!f.email },
+]
+</script>
+
+<template>
+  <Table :columns="resource.columns" :records="resource.records" />
+  <BlueprintForm v-model="form" :fields="fields" label="Profile" />
+</template>
+```
+
+## Server-driven tables
+
+`SchemaTable` renders columns, filters, groups, summaries and a query builder
+from a description the backend sends as a prop — no `columns` array in the
+page:
+
+```vue
+<SchemaTable
+  :schema="table"
+  :records="organizations.data"
+  :summaries="organizations.meta?.summaries ?? {}"
+  :filter-values="form"
+  @update:filter="setFilter"
+/>
+```
+
+It wraps `Table`, so pages using `Table` directly are unaffected, and any
+`#cell-{key}` or `#filters` slot you pass overrides the generated one.
+See [docs/table-schema.md](docs/table-schema.md).
+
+## Async writes
+
+Overlapping writes are normal in an admin panel — a toggle in a row, a
+debounced field, an optimistic star — and the failure modes are quiet. The
+package ships the ordering primitives rather than leaving each page to
+re-invent them:
+
+```js
+import { optimistic, writeKey, usePendingKeys } from '@modufolio/panel'
+
+const { isPending, run } = usePendingKeys()      // which row is busy
+
+const toggle = (row) => run(row.id, () => optimistic(
+  () => { const was = row.active; row.active = !was; return () => { row.active = was } },
+  () => apiFetch(url, { method: 'PATCH', body: { active: row.active } }),
+  writeKey('rows', row.id, 'active'),            // orders overlapping writes
+))
+```
+
+Also here: `useFieldSaver` (debounced saves with ordered status),
+`useUnsavedChangesWarning` (prompt before a navigation discards edits,
+logout included), `writeGate` (the ordering itself) and `moduleSingleton`
+(state that survives a duplicated module copy).
+See [docs/async-writes.md](docs/async-writes.md).
+
+## Extension seams
+
+- `registerFieldType(type, loader)` — add custom blueprint field types
+  (rich-text editors, media pickers, ...) without forking the package.
+  See [docs/custom-fields.md](docs/custom-fields.md).
+- `registerIcons(map)` — add or override icon names used by `<Icon>`.
+- `setPanelBaseUrl('/admin')` / `panelUrl(path)` — mount-path handling.
+
+## Server contract
+
+Works with any Inertia backend. A few small server-side conventions:
+
+- **Overlays** — layer stack, scroll lock, positioning, keyboard:
+  [docs/overlays.md](docs/overlays.md)
+- **Drawers** — [docs/drawer-protocol.md](docs/drawer-protocol.md)
+- **Table schema** — [docs/table-schema.md](docs/table-schema.md)
+- **Relation fields** — lookup search/create endpoints, repeater rows and
+  row-addressed errors: [docs/relation-fields.md](docs/relation-fields.md)
+
+The reference implementation is appkit + appkit-portfolio.
+
+## Tests
+
+```bash
+npm test            # inside packages/panel
+```
+
+Specs live in `tests/`, one file per module or component, run by the
+package's own `vitest.config.ts` against `happy-dom`. Component specs mount
+with `@vue/test-utils`; field components resolve asynchronously through the
+registry, so wait for rendered output (`vi.waitFor`) rather than a fixed
+number of ticks.
+
+## License
+
+MIT

package/dist/Builder/ImageNodeView.d.ts

@@ -0,0 +1,33 @@
+import { EditorView, NodeView } from 'prosemirror-view';
+import { Node as PMNode } from 'prosemirror-model';
+export interface ImageNodeViewOptions {
+    /** Opens the media library; resolves with the chosen image, or null. */
+    pickImage: () => Promise<{
+        id: string;
+        url: string;
+        thumbnail_url: string;
+        alt_text?: string;
+        caption?: string;
+    } | null>;
+    /** Opens the media detail view for an image, as double-click does in the library. */
+    openMedia?: (id: string) => void;
+}
+export declare class ImageNodeView implements NodeView {
+    private node;
+    private view;
+    private getPos;
+    private options;
+    dom: HTMLElement;
+    private img;
+    private captionEl;
+    private placeholder;
+    constructor(node: PMNode, view: EditorView, getPos: () => number | undefined, options: ImageNodeViewOptions);
+    private buildToolbar;
+    private pick;
+    private setAttrs;
+    private render;
+    update(node: PMNode): boolean;
+    /** The node has no editable content, so ignore mutations inside it. */
+    ignoreMutation(): boolean;
+    stopEvent(event: Event): boolean;
+}

package/dist/Builder/document.d.ts

@@ -0,0 +1,17 @@
+import { Node as PMNode } from 'prosemirror-model';
+export type ParseStatus = 'ok' | 'empty' | 'unreadable';
+export interface ParseResult {
+    doc: PMNode;
+    status: ParseStatus;
+    /** Set when status is 'unreadable': why, for the field to show. */
+    reason?: string;
+}
+export declare function emptyDoc(): PMNode;
+/**
+ * Read a stored field value.
+ *
+ * Never throws. A document that cannot be parsed comes back as `unreadable`
+ * with an empty document alongside, so the caller can refuse to overwrite it.
+ */
+export declare function parseStoredValue(value: string): ParseResult;
+export declare function serializeDoc(doc: PMNode): string;

package/dist/Builder/dragHandle.d.ts

@@ -0,0 +1,13 @@
+import { Plugin } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+/**
+ * Begin dragging the top-level block at `pos`.
+ *
+ * Exported so it can be tested without a layout engine: everything above it is
+ * hover geometry, and everything below it is ProseMirror's.
+ *
+ * Returns false when the position does not hold a draggable block, leaving the
+ * event alone rather than starting a drag that cannot finish.
+ */
+export declare function startBlockDrag(view: EditorView, pos: number, event: DragEvent): boolean;
+export declare function blockDragHandle(): Plugin;

package/dist/Builder/editing.d.ts

@@ -0,0 +1,53 @@
+import { Command, EditorState } from 'prosemirror-state';
+import { MarkType, NodeType } from 'prosemirror-model';
+/** Whether `type` applies anywhere in the current selection. */
+export declare function isMarkActive(state: EditorState, type: MarkType): boolean;
+/** Whether the selection sits inside a `type` block with these attrs. */
+export declare function isBlockActive(state: EditorState, type: NodeType, attrs?: Record<string, unknown>): boolean;
+/** Whether the selection is inside a list of this type. */
+export declare function isInList(state: EditorState, type: NodeType): boolean;
+/** The href on the link mark under the cursor, or '' if there is none. */
+export declare function activeLinkHref(state: EditorState): string;
+export declare const commands: {
+    toggleStrong: Command;
+    toggleEm: Command;
+    toggleCode: Command;
+    setParagraph: Command;
+    setHeading: (level: number) => Command;
+    setCodeBlock: Command;
+    toggleBulletList: Command;
+    toggleOrderedList: Command;
+    wrapBlockquote: Command;
+    lift: Command;
+    undo: Command;
+    redo: Command;
+    /**
+     * Apply or replace the link mark over the selection.
+     *
+     * `href` is not validated here — `schema.marks.link` does it in `toDOM`, and
+     * the field validates before calling. Passing '' removes the mark.
+     */
+    setLink: (href: string) => Command;
+    /**
+     * Replace the current (empty) textblock with a node of `type`.
+     * Used by the slash menu, where the user has typed `/` into a fresh block.
+     */
+    replaceBlockWith: (type: NodeType, attrs?: Record<string, unknown>) => Command;
+};
+/**
+ * Markdown-ish shortcuts. These are *not* a Markdown parser — each rule fires
+ * on a literal prefix as it is typed and produces a schema node directly, so
+ * there is no intermediate HTML and nothing to keep in sync with the server.
+ */
+export declare function builderInputRules(): import('prosemirror-state').Plugin<{
+    transform: import('prosemirror-state').Transaction;
+    from: number;
+    to: number;
+    text: string;
+} | null>;
+/**
+ * `onLink` is called for the link shortcut; the field opens its own input
+ * rather than a `window.prompt`, so the keymap only signals intent.
+ */
+export declare function builderKeymap(onLink: () => void): import('prosemirror-state').Plugin<any>[];
+export declare function builderHistory(): import('prosemirror-state').Plugin<any>;

package/dist/Builder/plugins.d.ts

@@ -0,0 +1,27 @@
+import { Plugin, PluginKey, EditorState } from 'prosemirror-state';
+/**
+ * Show `text` on the first block while the document is empty.
+ *
+ * Implemented as a widget-free node decoration carrying a CSS class, so the
+ * prompt lives in a `::before` and can never be mistaken for content.
+ */
+export declare function placeholder(text: string): Plugin;
+export declare const slashMenuKey: PluginKey<SlashMenuState>;
+export interface SlashMenuState {
+    /** Position of the `/` in the document, or null when the menu is closed. */
+    from: number | null;
+    /** What the user has typed after the `/`, for filtering. */
+    query: string;
+}
+/**
+ * Track a `/` typed at the start of an empty paragraph, plus whatever is typed
+ * after it, so the field can render a filtered block menu.
+ *
+ * State only — the menu component decides what to show and dispatches the
+ * command. Closing is driven by the text no longer matching, so Escape and any
+ * edit elsewhere both dismiss it without extra bookkeeping.
+ */
+export declare function slashMenu(): Plugin<SlashMenuState>;
+export declare function getSlashMenuState(state: EditorState): SlashMenuState;
+/** Close the menu and remove the `/query` text the user typed. */
+export declare function closeSlashMenu(state: EditorState, clearText: boolean): import('prosemirror-state').Transaction;

package/dist/Builder/schema.d.ts

@@ -0,0 +1,20 @@
+import { Schema } from 'prosemirror-model';
+export declare const HEADING_LEVELS: readonly [2, 3, 4, 5, 6];
+export declare const IMAGE_WIDTHS: readonly ["default", "wide", "full"];
+export declare const CODE_LANGUAGES: readonly ["plain", "bash", "css", "html", "json", "js", "ts", "php", "python", "sql", "vue", "yaml", "markdown"];
+export type HeadingLevel = (typeof HEADING_LEVELS)[number];
+export type ImageWidth = (typeof IMAGE_WIDTHS)[number];
+export type CodeLanguage = (typeof CODE_LANGUAGES)[number];
+/**
+ * An href we are willing to render, or null.
+ *
+ * Applied on the way in (`parseDOM`, so a pasted link cannot smuggle a scheme
+ * into the document) and again on the way out (`toDOM`, so a document that
+ * reached us some other way still cannot render one). ProseMirror does not
+ * validate URLs — this is the one classic XSS vector the document model does
+ * not close on its own, and it has produced High-severity advisories in other
+ * ProseMirror-based CMSs (see docs/prosemirror-builder.md §3.3).
+ */
+export declare function safeHref(value: unknown): string | null;
+export declare const schema: Schema<"text" | "blockquote" | "image" | "heading" | "doc" | "paragraph" | "code_block" | "bullet_list" | "ordered_list" | "list_item" | "hard_break", "code" | "em" | "link" | "strong">;
+export type BuilderSchema = typeof schema;

package/dist/Components/Actions/Action.vue.d.ts

@@ -0,0 +1,116 @@
+import { PropType } from 'vue';
+declare var __VLS_13: {}, __VLS_15: {}, __VLS_29: {};
+type __VLS_Slots = {} & {
+    'icon-before'?: (props: typeof __VLS_13) => any;
+} & {
+    default?: (props: typeof __VLS_15) => any;
+} & {
+    'icon-after'?: (props: typeof __VLS_29) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    icon: {
+        type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
+        default: null;
+    };
+    iconPosition: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+    variant: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+    size: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    type: {
+        type: PropType<"button" | "submit" | "reset">;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    icon: {
+        type: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
+        default: null;
+    };
+    iconPosition: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+    variant: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+    size: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    type: {
+        type: PropType<"button" | "submit" | "reset">;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+}>> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: string;
+    label: string;
+    type: "button" | "reset" | "submit";
+    disabled: boolean;
+    color: string;
+    icon: string | Function | Record<string, any>;
+    iconPosition: string;
+    variant: string;
+    ariaLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Components/Actions/ActionGroup.vue.d.ts

@@ -0,0 +1,25 @@
+declare var __VLS_13: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    label: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Components/Actions/ActionGroupItem.vue.d.ts

@@ -0,0 +1,48 @@
+declare var __VLS_11: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    icon: {
+        type: (StringConstructor | ObjectConstructor)[];
+        default: null;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    icon: {
+        type: (StringConstructor | ObjectConstructor)[];
+        default: null;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+}>> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+}>, {
+    color: string;
+    icon: string | Record<string, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Components/Auth/ForgotPassword.vue.d.ts

@@ -0,0 +1,17 @@
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    logo?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    csrf_token: StringConstructor;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    csrf_token: StringConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Components/Auth/Login.vue.d.ts

@@ -0,0 +1,33 @@
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    logo?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    csrf_token: {
+        type: StringConstructor;
+        required: true;
+    };
+    google_enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    csrf_token: {
+        type: StringConstructor;
+        required: true;
+    };
+    google_enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    google_enabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Components/Auth/ResetPassword.vue.d.ts

@@ -0,0 +1,27 @@
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    logo?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    valid: BooleanConstructor;
+    token: StringConstructor;
+    email: StringConstructor;
+    csrf_token: StringConstructor;
+    errors: ObjectConstructor;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    valid: BooleanConstructor;
+    token: StringConstructor;
+    email: StringConstructor;
+    csrf_token: StringConstructor;
+    errors: ObjectConstructor;
+}>> & Readonly<{}>, {
+    valid: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Components/Auth/TwoFactor.vue.d.ts

@@ -0,0 +1,32 @@
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    enabled: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    confirmed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enabled_at: {
+        type: StringConstructor;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    enabled: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    confirmed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enabled_at: {
+        type: StringConstructor;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    confirmed: boolean;
+    enabled_at: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;