@maildeno/editor 0.1.3 → 0.4.2

package/dist/RowPreviewRow-N-hh5l_H.js

@@ -0,0 +1,112 @@
+import { n as defineComponent, o as computed, q as openBlock, t as createElementBlock, F as Fragment, u as renderList, v as normalizeStyle, w as createVNode, x as unref, y as createCommentVNode, z as defineAsyncComponent } from "./element-C2ZH0Z_i.js";
+const _hoisted_1 = {
+  key: 0,
+  class: "w-full border border-dashed border-(--md-border) rounded",
+  style: { "min-height": "10px" }
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "RowPreviewRow",
+  props: {
+    row: {},
+    scale: {},
+    depth: {}
+  },
+  setup(__props) {
+    const RowPreviewChildren = defineAsyncComponent(
+      () => import("./RowPreviewChildren-DT0y0lKC.js")
+    );
+    const props = __props;
+    function resolveBackground(item) {
+      var _a;
+      const bg = item == null ? void 0 : item.backgroundGradient;
+      const hasGradient = (bg == null ? void 0 : bg.useGradient) === true && Array.isArray((_a = bg == null ? void 0 : bg.gradient) == null ? void 0 : _a.colors) && bg.gradient.colors.length >= 2;
+      if (hasGradient) {
+        const { type, direction, colors } = bg.gradient;
+        const stops = colors.map((c) => `${c.color} ${c.position}%`).join(", ");
+        return type === "radial" ? `radial-gradient(circle at center, ${stops})` : `linear-gradient(${direction}, ${stops})`;
+      }
+      return (item == null ? void 0 : item.backgroundColor) ?? "transparent";
+    }
+    const rowStyle = computed(() => {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      const r = props.row;
+      const style = {
+        display: "flex",
+        flexDirection: "row",
+        background: resolveBackground(r),
+        padding: `${((_a = r.padding) == null ? void 0 : _a.top) ?? 0}px ${((_b = r.padding) == null ? void 0 : _b.right) ?? 0}px ${((_c = r.padding) == null ? void 0 : _c.bottom) ?? 0}px ${((_d = r.padding) == null ? void 0 : _d.left) ?? 0}px`,
+        alignItems: "stretch",
+        border: `${((_e = r.border) == null ? void 0 : _e.width) ?? 0}px ${((_f = r.border) == null ? void 0 : _f.style) ?? "solid"} ${((_g = r.border) == null ? void 0 : _g.color) ?? "transparent"}`,
+        borderRadius: `${((_h = r.border) == null ? void 0 : _h.radius) ?? 0}px`,
+        gap: `${r.gap ?? 0}px`,
+        overflow: "hidden"
+      };
+      if (r.backgroundImage) {
+        style.backgroundImage = `url(${r.backgroundImage})`;
+        style.backgroundSize = r.backgroundSize ?? "cover";
+        style.backgroundPosition = r.backgroundPosition ?? "center center";
+      }
+      return style;
+    });
+    function colStyle(col, parentRow) {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+      const verticalAlignMap = {
+        top: "flex-start",
+        middle: "center",
+        bottom: "flex-end"
+      };
+      const widthPct = col.width ?? 50;
+      const siblingCount = ((_a = parentRow == null ? void 0 : parentRow.columns) == null ? void 0 : _a.length) || 1;
+      const gapPx = (parentRow == null ? void 0 : parentRow.gap) ?? 0;
+      const gapShare = siblingCount > 1 ? gapPx * (siblingCount - 1) / siblingCount : 0;
+      const widthValue = gapShare > 0 ? `calc(${widthPct}% - ${gapShare}px)` : `${widthPct}%`;
+      const style = {
+        flex: `0 0 ${widthValue}`,
+        width: widthValue,
+        maxWidth: widthValue,
+        boxSizing: "border-box",
+        background: resolveBackground(col),
+        padding: `${((_b = col.padding) == null ? void 0 : _b.top) ?? 10}px ${((_c = col.padding) == null ? void 0 : _c.right) ?? 10}px ${((_d = col.padding) == null ? void 0 : _d.bottom) ?? 10}px ${((_e = col.padding) == null ? void 0 : _e.left) ?? 10}px`,
+        border: `${((_f = col.border) == null ? void 0 : _f.width) ?? 0}px ${((_g = col.border) == null ? void 0 : _g.style) ?? "solid"} ${((_h = col.border) == null ? void 0 : _h.color) ?? "transparent"}`,
+        borderRadius: `${((_i = col.border) == null ? void 0 : _i.radius) ?? 0}px`,
+        overflow: "hidden",
+        minWidth: "0",
+        display: "flex",
+        flexDirection: "column",
+        justifyContent: verticalAlignMap[col.verticalAlign] ?? "flex-start"
+      };
+      if (col.backgroundImage) {
+        style.backgroundImage = `url(${col.backgroundImage})`;
+        style.backgroundSize = col.backgroundSize ?? "cover";
+        style.backgroundPosition = col.backgroundPosition ?? "center center";
+        style.minHeight = "14px";
+      }
+      return style;
+    }
+    return (_ctx, _cache) => {
+      return (__props.depth ?? 0) < 5 ? (openBlock(), createElementBlock("div", {
+        key: 0,
+        style: normalizeStyle(rowStyle.value),
+        class: "w-full"
+      }, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(__props.row.columns ?? [], (col) => {
+          return openBlock(), createElementBlock("div", {
+            key: col.id,
+            style: normalizeStyle(colStyle(col, __props.row)),
+            class: "overflow-hidden shrink-0"
+          }, [
+            createVNode(unref(RowPreviewChildren), {
+              children: col.children ?? col.components ?? [],
+              scale: __props.scale,
+              depth: (__props.depth ?? 0) + 1
+            }, null, 8, ["children", "scale", "depth"]),
+            (col.children ?? col.components ?? []).length === 0 ? (openBlock(), createElementBlock("div", _hoisted_1)) : createCommentVNode("", true)
+          ], 4);
+        }), 128))
+      ], 4)) : createCommentVNode("", true);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/adapters/errors.d.ts

@@ -0,0 +1,59 @@
+/**
+ * adapters/errors.ts — the one thing the editor and a host adapter need to
+ * agree on about failure.
+ *
+ * The editor has no user, role, plan or HTTP model, deliberately (see the
+ * README's "Positioning" section, and the comment at the top of
+ * SavedRowsPanel.vue). So it cannot say anything useful about a 403, a 402 or
+ * an expired session — only the host knows what its own statuses mean and
+ * what the user should do about them.
+ *
+ * That leaves a gap. A host adapter that catches its own 403 and shows a
+ * precise message ("your role can't delete saved rows — ask an admin") gets a
+ * second, vaguer toast from the editor's own catch block a moment later
+ * ("Delete failed"). Two toasts for one click, the less useful one last.
+ *
+ * `handled` closes it without teaching the editor anything about permissions.
+ * The host marks an error it has already surfaced; the editor only asks "did
+ * someone already tell the user?" and stays quiet if so. It still gets the
+ * rejection — which matters, because every optimistic update in this package
+ * is applied on resolve, so a swallowed failure would leave the UI showing a
+ * delete or rename that never happened.
+ *
+ * Hosts that don't use this lose nothing: unmarked errors take the editor's
+ * generic message exactly as before.
+ */
+/**
+ * Marks an error as already reported to the user, and returns it for
+ * rethrowing:
+ *
+ * ```ts
+ * catch (err) {
+ *   toast.add({ severity: "warn", summary: "Not allowed", detail });
+ *   throw markHandled(err);
+ * }
+ * ```
+ *
+ * Mutates in place when it can, so `err.status` / `err.data` and any other
+ * fields the host reads downstream survive. Some rejections can't be mutated
+ * — ofetch's FetchError is frozen, and a thrown string isn't an object at all
+ * — so those get a fresh Error carrying the original as `cause` rather than
+ * throwing a TypeError from inside a catch block, which would replace the
+ * real failure with a confusing one.
+ */
+export declare function markHandled(err: unknown): unknown;
+/**
+ * Whether the host already showed the user a message for this failure.
+ *
+ * Guard the editor's own toast with it, never the recovery logic — a handled
+ * error is still an error, and state that was rolled back or a panel that was
+ * left open must behave identically either way:
+ *
+ * ```ts
+ * catch (err) {
+ *   console.error("[maildeno-editor] failed to delete version:", err);
+ *   if (!isHandled(err)) toast.add({ severity: "error", summary: "Delete failed" });
+ * }
+ * ```
+ */
+export declare function isHandled(err: unknown): boolean;

package/dist/adapters/index.d.ts

@@ -1,7 +1,38 @@
+import { Ref } from 'vue';
 import { EditorStorageAdapter, PartialStorageAdapter } from './types';
+export declare function useCanSave(): Ref<boolean>;
+export declare function provideCanSave(canSave: Ref<boolean>): void;
+export declare function useHasTemplateLibrary(): boolean;
 export declare function provideStorageAdapter(adapter?: PartialStorageAdapter): EditorStorageAdapter;
 /** For genuine child components of <EmailEditor> — Header.vue,
  * SavedRowsPanel.vue, etc. Their inject() correctly sees EmailEditor.vue's
  * provides via instance.parent.provides, since they're actual children,
  * not the same instance that called provide(). */
 export declare const useStorageAdapter: () => EditorStorageAdapter;
+/**
+ * Host-declared restrictions on the saved-row library.
+ *
+ * Same contract as EmailEditor's `capabilities` prop that carries it: this
+ * only ever takes affordances away. Omitting a key, or the whole object,
+ * leaves that control exactly as it is today, so no existing host changes
+ * behaviour by upgrading.
+ *
+ * Separate from the read-only Shared tab, which is a property of the data (no
+ * adapter method backs renaming an org's curated rows, so no host can grant
+ * it). This is a property of the *person* — a viewer in a host's role model
+ * who may look at their org's rows but not add to them. The editor still has
+ * no user model and isn't learning one: it takes three booleans and asks no
+ * questions about where they came from.
+ *
+ * A gate is not enforcement. The server is still the only thing standing
+ * between a viewer and a write; this just stops the editor offering a button
+ * whose only outcome is a 403.
+ */
+export interface SavedRowCapabilities {
+    create?: boolean;
+    rename?: boolean;
+    delete?: boolean;
+}
+export declare function provideSavedRowCapabilities(caps: Ref<SavedRowCapabilities>): void;
+/** Defaults to fully permitted — see the "only ever restricts" note above. */
+export declare function useSavedRowCapabilities(): Ref<SavedRowCapabilities>;

package/dist/adapters/types.d.ts

@@ -28,6 +28,27 @@ export interface TemplateSummary {
     name?: string;
     updatedAt?: string;
 }
+/**
+ * One entry in the version-history panel. A summary for the same reason
+ * TemplateSummary is: rendering a list of fifty versions shouldn't mean
+ * downloading fifty full documents. getTemplateVersion(id) fetches content
+ * for the one the user actually restores.
+ */
+export interface TemplateVersionSummary {
+    versionId: string;
+    createdAt: string;
+    /** Optional human label ("Before redesign"). Falls back to a relative
+     *  timestamp in the panel when absent. */
+    label?: string;
+    /** Pinned. Kept versions are excluded from deleteAllTemplateVersions and
+     *  are the ones a host's retention policy should spare. The editor only
+     *  reads and toggles this; what "spared" means is the host's business. */
+    kept?: boolean;
+    /** Free-form attribution, shown verbatim if present. Deliberately a
+     *  string, not a user object — the editor has no user model and shouldn't
+     *  grow one just to render a name. */
+    author?: string;
+}
 export interface SavedRow {
     id: string;
     name: string;
@@ -51,7 +72,54 @@ export interface EditorStorageAdapter {
     listTemplates(): Promise<TemplateSummary[]>;
     /** Optional, and only surfaced in the panel when implemented. */
     deleteTemplate(templateId: string): Promise<void>;
+    /**
+     * ── Version history ──────────────────────────────────────────────────
+     *
+     * All five are optional, like listTemplates above, and gated the same
+     * way: the panel is only reachable when `versions` is set on the editor,
+     * and each control within it only appears when its method exists. An
+     * adapter can therefore support listing and restoring without supporting
+     * deletion, and the UI reflects exactly that.
+     *
+     * Note the asymmetry with saveTemplate: nothing here creates a version.
+     * When a save produces a new version is a policy question — every save,
+     * on a timer, on explicit request — and the host already owns saveTemplate,
+     * so it can decide there. Putting version creation in this interface would
+     * force one policy on every host.
+     */
+    listTemplateVersions(templateId: string): Promise<TemplateVersionSummary[]>;
+    /** Full content for one version, in the same shape as loadTemplate. */
+    getTemplateVersion(templateId: string, versionId: string): Promise<TemplateSnapshot | null>;
+    deleteTemplateVersion(templateId: string, versionId: string): Promise<void>;
+    /** Bulk delete. Kept versions survive — see TemplateVersionSummary.kept.
+     *  The panel's confirm copy says so, so an implementation that deletes
+     *  kept versions too would contradict what the user was told. */
+    deleteAllTemplateVersions(templateId: string): Promise<void>;
+    setTemplateVersionKept(templateId: string, versionId: string, kept: boolean): Promise<void>;
     listSavedRows(): Promise<SavedRow[]>;
+    /**
+     * A second, read-only row library shown in its own tab beside the user's
+     * own rows — an organisation's shared blocks, a starter set, whatever the
+     * host curates.
+     *
+     * Optional, and the tab only appears when it is implemented, so a host with
+     * one row library sees exactly the panel it has today. The built-in
+     * localStorage adapter deliberately does NOT implement it: "shared across
+     * an organisation" has no meaning in a single browser's storage, and
+     * faking it would demonstrate a feature that cannot work.
+     *
+     * Read-only by construction. There is no saveSystemSavedRow /
+     * deleteSystemSavedRow / renameSystemSavedRow, so the panel renders this
+     * tab without rename or delete controls. Who may curate a shared library is
+     * a permissions question the host answers in its own admin UI — the editor
+     * has no user model to answer it with, and inventing one to grey out a
+     * button would be the wrong boundary.
+     *
+     * cloneSavedRowForCanvas must resolve ids from BOTH libraries. It is the
+     * single synchronous entry point used when a row is dragged onto the
+     * canvas, and the drag doesn't know which tab the row came from.
+     */
+    listSystemSavedRows(): Promise<SavedRow[]>;
     saveSavedRow(row: Record<string, any>, name: string): Promise<SavedRow | null>;
     deleteSavedRow(id: string): Promise<void>;
     renameSavedRow(id: string, name: string): Promise<void>;

package/dist/brand.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The package's own name, shown wherever a host hasn't supplied its own.
+ *
+ * Extracted to a constant because two components now render it — the
+ * desktop-only notice and the loading overlay — and DesktopOnlyNotice.vue's
+ * prop comment already promised there would be exactly one place to change
+ * it. A second `withDefaults(..., { brandName: "Maildeno" })` written inline
+ * would quietly make that false, and the two would drift the first time
+ * someone renamed one of them.
+ *
+ * Not a theme token: `theme` carries colours, and this is text, so it has no
+ * sensible home in the token map — see the `brandName` prop on EmailEditor
+ * for the longer version of that reasoning.
+ */
+export declare const DEFAULT_BRAND_NAME = "Maildeno";

package/dist/components/DesktopOnlyNotice.vue.d.ts

@@ -0,0 +1,20 @@
+interface Props {
+    /**
+     * Name shown in the "Powered by" line at the bottom of the notice.
+     *
+     * EmailEditor.vue forwards the prop through without redeclaring a default
+     * of its own, so an undefined value arriving from any of the three mount
+     * paths (Vue component, custom element, light DOM) lands here and resolves
+     * the same way. Pass an empty string to hide the line entirely.
+     *
+     * The default itself now lives in brand.ts — Loader.vue renders the same
+     * name, and two inline copies of the string would be two things to keep in
+     * step. Behaviour here is unchanged.
+     */
+    brandName?: string;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    brandName: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/features/emailBuilder/EmailEditor.vue.d.ts

@@ -0,0 +1,182 @@
+import { ColorMode } from '../../../composables/system/useColorScheme';
+import { PartialStorageAdapter } from '../../../adapters/types';
+import { ThemeOptions } from '../../../theme';
+import { AssistantMount, EditorWriteApi } from '../../../types/assistant';
+type __VLS_Props = {
+    isReady?: boolean;
+    storageAdapter?: PartialStorageAdapter;
+    /** If given, loaded via the adapter on mount. Omit to start blank
+     * (create mode) — matches the original app's /create vs /edit split,
+     * now driven by a prop instead of a route. */
+    templateId?: string;
+    /** Applied via CSS custom properties (see theme.ts) — works whether this
+     * component is used directly or wrapped by element.ts's
+     * defineCustomElement, because both write to the same place: this
+     * component's own root element, which is where the package's bundled
+     * defaults land too once the library build has scoped them. Reactive:
+     * assigning a new object re-themes live, no remount. */
+    theme?: ThemeOptions;
+    /**
+     * Which half of `theme` applies.
+     *
+     * `auto` (the default) follows the host page: useColorScheme.ts watches
+     * for a `dark` class on <html> or <body> and mirrors it onto the editor
+     * root. A host that already has a Tailwind-style theme switcher needs no
+     * wiring at all — flipping the class moves the editor in the same frame.
+     *
+     * Pass `light` or `dark` to pin the editor regardless of the page: a
+     * light editor deliberately embedded in a dark shell, or a host whose
+     * switcher signals something other than a class.
+     */
+    colorMode?: ColorMode;
+    /** If provided, the "Send test" button appears in the header. Editor
+     * owns the form/validation UI; this callback owns what actually
+     * happens on submit (SMTP, an API, anything) — same host-owns-the-
+     * operation pattern as the storage adapter. */
+    /**
+     * Called after a successful save. Its presence is what reveals the Save
+     * button — same idiom as onSendTestEmail below.
+     *
+     * Gating on an explicit handler rather than on the storage adapter,
+     * because the adapter can't answer the question: PartialStorageAdapter
+     * is merged with the localStorage defaults, so `saveTemplate` always
+     * exists by the time anything reads it. A host that wants a read-only or
+     * guest editor simply omits this.
+     *
+     * The `save` event still fires alongside, so `@save` keeps working — and
+     * because Vue compiles `@save="fn"` to an `onSave` prop, writing the
+     * listener is itself enough to reveal the button.
+     */
+    onSave?: (payload: {
+        templateId: string | null;
+    }) => void;
+    /**
+     * The same handler, under a name that doesn't begin with "on".
+     *
+     * For the custom-element path only. Vue's defineCustomElement treats
+     * `on*` keys as event listeners rather than props, so `el.onSave = fn`
+     * never reaches this component — the button appeared and the callback
+     * never fired. init() sets this instead. Vue hosts should use `@save`.
+     */
+    saveHandler?: (payload: {
+        templateId: string | null;
+    }) => void;
+    onSendTestEmail?: (payload: {
+        to: string;
+        subject: string;
+        html: string;
+    }) => Promise<void> | void;
+    /** Explicit UI restrictions, layered on top of the implicit ones
+     * (e.g. onSendTestEmail's mere presence/absence already gates that
+     * button — capabilities doesn't replace that, it adds to it).
+     * Omit any key to leave that area fully enabled — this restricts,
+     * it never grants something that wasn't already possible. */
+    capabilities?: {
+        /** Which formats appear in the Export dropdown. Omit for all four. */
+        export?: Array<"html" | "mjml" | "react" | "json">;
+        /** Which saved-row controls this user gets: the canvas row's bookmark
+         * button, and the panel's per-row rename and delete. Omit a key for
+         * "allowed", the same as omitting the object. For a host with roles,
+         * this is what stops a viewer being shown three buttons that can only
+         * 403 — the toast their adapter raises afterwards is the backstop, not
+         * the design. Does not touch the Shared tab, which is read-only for
+         * everyone because no adapter method backs writing to it. */
+        savedRows?: {
+            create?: boolean;
+            rename?: boolean;
+            delete?: boolean;
+        };
+    };
+    /** Name shown in the loading overlay and in the desktop-only notice's
+     * "Powered by" line.
+     *
+     * Deliberately a prop rather than a theme token: `theme` carries
+     * colours, and this is text, so it has no sensible home in the token
+     * map. It is also the one piece of chrome a host cannot restyle away,
+     * since the notice replaces the entire editor on small screens.
+     *
+     * No default is declared here on purpose. Both consumers resolve an
+     * undefined value from DEFAULT_BRAND_NAME in brand.ts, so there is one
+     * place to change it rather than three that can drift — and declaring a
+     * default here would also make the empty-string case unreachable, since
+     * the prop would never arrive undefined. Omit for the package default;
+     * pass an empty string to render no wordmark and drop the attribution
+     * line entirely. */
+    brandName?: string;
+    /** Replaces the saved-templates panel (and its header button) with
+     * version history.
+     *
+     * A swap rather than an addition, because the two answer different
+     * questions — "which template?" versus "which state of this template?"
+     * — and a host that has its own template browser elsewhere in its app
+     * has no use for the former inside the editor. Two panels competing for
+     * the same slot would also mean two header buttons and a layout
+     * decision the editor shouldn't be making.
+     *
+     * Top-level rather than a `capabilities` key on purpose: capabilities
+     * documents itself as only ever restricting, never granting, and this
+     * grants.
+     *
+     * The panel still degrades per-method — see the version methods on
+     * EditorStorageAdapter. Setting this with an adapter that can't list
+     * versions gets an honest "not supported" message, not a broken panel. */
+    versions?: boolean;
+    /** Fills the assistant drawer from a non-Vue host (init(), React,
+     * vanilla). Vue hosts use the #assistant slot instead; either one being
+     * present reveals the trigger button, and neither means no assistant UI
+     * renders at all.
+     *
+     * The editor supplies the drawer, its trigger, open/close state, escape
+     * handling, focus return and shadow-DOM-safe teleporting. What goes
+     * inside is entirely the host's — see the AssistantPanel comment for
+     * why the assistant itself isn't in this package. */
+    assistant?: AssistantMount;
+};
+declare var __VLS_17: {
+    templateId: string | null;
+    isSaving: boolean;
+    saveStatus: import('../../../composables/emailBuilder/persistence/useEmailBuilderPersistence').AutoSaveStatus;
+}, __VLS_80: {
+    editor: EditorWriteApi;
+};
+type __VLS_Slots = {} & {
+    'header-actions'?: (props: typeof __VLS_17) => any;
+} & {
+    assistant?: (props: typeof __VLS_80) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    getHtml: (mode?: "prune" | "wrap") => string | null;
+    getMjml: (mode?: "prune" | "wrap") => string | null;
+    getReactEmail: (mode?: "prune" | "wrap") => string | null;
+    getJson: () => {
+        template_id: string;
+        template_name: string;
+        canvas: Partial<import('../../../composables/emailBuilder/transform/pipeline/optimize').Canvas>;
+        rows: Partial<import('../../../composables/emailBuilder/transform/pipeline/optimize').NestedRow | import('../../../composables/emailBuilder/transform/pipeline/optimize').RowSpacer>[];
+        schema_version: string;
+    } | null;
+    setJson: (data: any, opts?: {
+        history?: "undoable" | "reset";
+    }) => void;
+    getSelection: () => {
+        id: string;
+        type: string | null;
+    } | null;
+    setSelection: (id: string | null) => boolean;
+    onChange: (cb: () => void) => (() => void);
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    ready: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onReady?: (() => any) | undefined;
+}>, {
+    isReady: boolean;
+    colorMode: ColorMode;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, 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/features/emailBuilder/assistant/AssistantPanel.vue.d.ts

@@ -0,0 +1,37 @@
+import { EditorWriteApi } from '../../../../types/assistant';
+type __VLS_Props = {
+    /** Imperative filler for the init()/custom-element path. */
+    assistant?: {
+        mount: (el: HTMLElement, editor: EditorWriteApi) => void;
+        unmount?: (el: HTMLElement) => void;
+    };
+    /** True when the host passed a #assistant slot. Computed by the parent
+     *  rather than read from $slots here, because a parent forwarding its own
+     *  slot down always produces a truthy $slots entry in this child even when
+     *  the host supplied nothing — which would render an assistant button that
+     *  opens an empty drawer. */
+    hasSlot?: boolean;
+    /** Handed to the host so its panel can drive the canvas. */
+    editor: EditorWriteApi;
+};
+declare function close(): void;
+declare function toggle(): void;
+declare var __VLS_23: {
+    editor: EditorWriteApi;
+};
+type __VLS_Slots = {} & {
+    assistant?: (props: typeof __VLS_23) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    open: () => boolean;
+    close: typeof close;
+    toggle: typeof toggle;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, 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/features/emailBuilder/blocks/AnchorBlock.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/features/emailBuilder/blocks/ButtonBlock.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/features/emailBuilder/blocks/DividerBlock.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/features/emailBuilder/blocks/HeadingBlock.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/features/emailBuilder/blocks/ImageBlock.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/features/emailBuilder/blocks/ListBlock.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/features/emailBuilder/blocks/MenuBlock.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/features/emailBuilder/blocks/ParagraphBlock.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/features/emailBuilder/blocks/SocialsBlock.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/features/emailBuilder/blocks/SpacerBlock.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/features/emailBuilder/blocks/VideoBlock.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/features/emailBuilder/canvas/Canvas.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;