@maildeno/editor 0.1.0

package/dist/composables/emailBuilder/history/useHistory.d.ts

@@ -0,0 +1,16 @@
+export interface HistorySnapshot<T> {
+    state: T;
+    action: string;
+    timestamp: number;
+}
+export declare const useHistory: <T = unknown>() => {
+    canUndo: import('vue').ComputedRef<boolean>;
+    canRedo: import('vue').ComputedRef<boolean>;
+    historyStatus: import('vue').ComputedRef<string>;
+    saveState: (state: T, action?: string, immediate?: boolean) => void;
+    undo: () => T | null;
+    redo: () => T | null;
+    clearHistory: () => void;
+    initHistory: (initialState: T) => void;
+    version: import('vue').Ref<number, number>;
+};

package/dist/composables/emailBuilder/persistence/useEmailBuilderPersistence.d.ts

@@ -0,0 +1,38 @@
+export type AutoSaveStatus = "idle" | "saving" | "saved" | "error";
+export interface AutoSavePayload {
+    schemaVersion: string;
+    /** Which template this draft belongs to. Null for brand-new unsaved documents. */
+    templateId: string | null;
+    expiresAt: number;
+    touchedAt: number;
+    updatedAt: string;
+    /** Template display name — cached so the page title can be set without a DB fetch. */
+    name?: string;
+    /** Template tags — cached alongside name to fully avoid a DB fetch on draft restore. */
+    tags?: any[];
+    content: {
+        rows: any[];
+        canvas: Record<string, any>;
+    };
+}
+export interface RestoredDraft {
+    rows: any[];
+    canvas: Record<string, any>;
+    updatedAt: string;
+    /** Reflects the templateId stored in the payload — use this to verify the
+    * draft belongs to the currently open template before restoring it. */
+    templateId: string | null;
+    /** Cached template display name — set when the template was first loaded from DB. */
+    name?: string;
+    /** Cached template tags — set when the template was first loaded from DB. */
+    tags?: any[];
+}
+export declare const useEmailBuilderPersistence: () => {
+    saveToLocal: (rows: any[], canvas: Record<string, any>, templateId?: string | null, name?: string, tags?: any[]) => void;
+    flushSave: (rows: any[], canvas: Record<string, any>, templateId?: string | null, name?: string, tags?: any[]) => void;
+    loadFromLocal: () => RestoredDraft | null;
+    clearLocal: () => void;
+    hasDraft: (templateId?: string) => boolean;
+    saveStatus: import('vue').Ref<AutoSaveStatus, AutoSaveStatus>;
+    lastSaved: import('vue').Ref<Date | null, Date | null>;
+};

package/dist/composables/emailBuilder/preview/useClientPreview.d.ts

@@ -0,0 +1,127 @@
+export type ClientPlatform = "web" | "desktop" | "mobile";
+export type DarkModeStrategy = "respects-meta" | "near-black-swap" | "partial-transparent" | "none";
+export interface ClientCapabilities {
+    /** @font-face / Google Fonts <link> support. Falls back to the next
+     *  font in the `font-family` stack (typically Arial) when false. */
+    webFonts: boolean;
+    /** CSS gradients (linear / radial) on <td> background. Outlook desktop
+     *  needs VML for these — see `vml` below. */
+    gradients: boolean;
+    /** border-radius on <td>. Note: border-radius on <a> (your button output)
+     *  works much more broadly — even Outlook desktop renders rounded <a>
+     *  buttons since 2016 via the -webkit-border-radius alias. Use
+     *  `buttonBorderRadius` for the button-specific capability. */
+    tdBorderRadius: boolean;
+    /** border-radius on <a> elements styled as inline-block buttons.
+     *  Outlook desktop SUPPORTS this (since 2016 webkit). */
+    buttonBorderRadius: boolean;
+    /** box-shadow on <td> or <div>. Rare — only modern WebKit clients. */
+    boxShadow: boolean;
+    /** background-image / `background="..."` attribute on <td>. */
+    bgImageOnTd: boolean;
+    /** VML rendering — required for gradients and bg images in Outlook desktop.
+     *  When false, gradient/bg fallback to the solid `backgroundColor`. */
+    vml: boolean;
+    /** Honors <!--[if mso]> conditional comments. Used to feed Outlook
+     *  VML-only fallbacks. Universal Microsoft trait. */
+    msoConditionals: boolean;
+    /** Animated GIF support. Outlook desktop shows first frame only. */
+    animatedGifs: boolean;
+    /** <video> tag in email. Only Apple Mail and iOS Mail render this. */
+    videoTag: boolean;
+    /** SVG as <img src="*.svg">. Renders in all modern clients including
+     *  Outlook desktop (verified by QA) — file extension doesn't affect
+     *  rendering once the image is fetched via HTTP and decoded. */
+    svgImg: boolean;
+    /** Retina / 2x images via srcset / width attribute. */
+    retinaImages: boolean;
+    /** @media (max-width: 600px) query support for responsive design.
+     *  Outlook desktop classic ignores all <style> tags entirely. */
+    mediaQueries: boolean;
+    /** <style> tag in <head> respected at all. Gmail web strips it from
+     *  <head> but keeps inline styles. */
+    embeddedStyles: boolean;
+    /** `align="center"` attribute on <table> and `<td>`. Universal. */
+    tableAlign: boolean;
+    /** `padding` style on <td>. Universal in practice, but Outlook desktop
+     *  measures padding differently — included for completeness. */
+    tdPadding: boolean;
+    darkModeStrategy: DarkModeStrategy;
+}
+export interface EmailClient {
+    id: string;
+    name: string;
+    vendor: string;
+    platform: ClientPlatform;
+    /** Engine that powers rendering. */
+    engine: string;
+    /** Approximate global market share (%). For sorting; not displayed as fact. */
+    marketShare?: number;
+    /** Brand accent color for the client tile. */
+    accentColor: string;
+    /** Single emoji or short identifier shown in the card avatar. */
+    logoText: string;
+    capabilities: ClientCapabilities;
+    /** Maximum content width the client renders at (chrome-excluded). */
+    viewportWidth: number;
+    /** Short human description for tooltip / detail header. */
+    description: string;
+    /** When previewing on this client, treat the layout as mobile (forces
+     *  mobile-only CSS classes to apply and triggers `mobileStack` if set). */
+    forcesMobile: boolean;
+}
+declare function hydrateFromStorage(): void;
+export declare function useClientPreview(): {
+    selectedClients: import('vue').ComputedRef<EmailClient[]>;
+    availableClients: import('vue').ComputedRef<EmailClient[]>;
+    allClients: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly vendor: string;
+        readonly platform: ClientPlatform;
+        readonly engine: string;
+        readonly marketShare?: number | undefined;
+        readonly accentColor: string;
+        readonly logoText: string;
+        readonly capabilities: {
+            readonly webFonts: boolean;
+            readonly gradients: boolean;
+            readonly tdBorderRadius: boolean;
+            readonly buttonBorderRadius: boolean;
+            readonly boxShadow: boolean;
+            readonly bgImageOnTd: boolean;
+            readonly vml: boolean;
+            readonly msoConditionals: boolean;
+            readonly animatedGifs: boolean;
+            readonly videoTag: boolean;
+            readonly svgImg: boolean;
+            readonly retinaImages: boolean;
+            readonly mediaQueries: boolean;
+            readonly embeddedStyles: boolean;
+            readonly tableAlign: boolean;
+            readonly tdPadding: boolean;
+            readonly darkModeStrategy: DarkModeStrategy;
+        };
+        readonly viewportWidth: number;
+        readonly description: string;
+        readonly forcesMobile: boolean;
+    }[];
+    activeClientId: Readonly<import('vue').Ref<string | null, string | null>>;
+    activeClient: import('vue').ComputedRef<EmailClient | null>;
+    activeClientIndex: import('vue').ComputedRef<number>;
+    hasNext: import('vue').ComputedRef<boolean>;
+    hasPrev: import('vue').ComputedRef<boolean>;
+    isHydrated: Readonly<import('vue').Ref<boolean, boolean>>;
+    addClient: (id: string) => void;
+    removeClient: (id: string) => void;
+    setActiveClient: (id: string | null) => void;
+    goToNextClient: () => void;
+    goToPrevClient: () => void;
+    resetToDefaults: () => void;
+    hydrateFromStorage: typeof hydrateFromStorage;
+    transformForClient: (html: string, client: EmailClient) => string;
+    darkModeCss: (client: EmailClient, isDark: boolean) => string;
+    darkChromeBg: (isDark: boolean) => string;
+    applyDarkModeDom: (doc: Document | null | undefined, client: EmailClient, isDark: boolean) => void;
+};
+export {};

package/dist/composables/emailBuilder/transform/pipeline/hydrate.d.ts

@@ -0,0 +1,54 @@
+/**
+ * hydrate.ts
+ * Restores stripped defaults when importing an optimized JSON template.
+ *
+ * Strategy: deepMerge(DEFAULTS, saved) — saved value always wins;
+ * stripped keys fall back to current defaults automatically.
+ *
+ * Now supports both new `children` shape and legacy `components` shape per column.
+ * On hydration, columns are always written with `children` going forward.
+ */
+interface Component {
+    id: string;
+    type: string;
+    componentType?: string;
+    props: Record<string, unknown>;
+}
+type CanvasChild = Component | NestedRow | RowSpacer;
+interface Column {
+    id: string;
+    width: number;
+    children?: CanvasChild[];
+    components?: Component[];
+    [key: string]: unknown;
+}
+interface NestedRow {
+    id: string;
+    type: "row";
+    columns?: Column[];
+    [key: string]: unknown;
+}
+interface RowSpacer {
+    id: string;
+    type: "row-spacer";
+    [key: string]: unknown;
+}
+type Row = NestedRow | RowSpacer;
+interface Canvas {
+    language?: string;
+    preheaderText?: string;
+    bodyBackgroundColor?: string;
+    bodyBackgroundImage?: string;
+    bodyBackgroundSize?: string;
+    bodyBackgroundPosition?: string;
+    bodyBackgroundRepeat?: string;
+    backgroundColor?: string;
+    width?: number;
+    padding?: Record<string, number>;
+    mobileBreakpoint?: number;
+    [key: string]: unknown;
+}
+export declare const hydrateComponent: (comp: Component) => Component;
+export declare const hydrateCanvas: (canvas: Canvas) => Canvas;
+export declare const hydrateRows: (rows: Row[]) => Row[];
+export {};

package/dist/composables/emailBuilder/transform/pipeline/optimize.d.ts

@@ -0,0 +1,101 @@
+/**
+ * optimize.ts
+ * Strips default/noise values from rows, columns, components, and canvas before
+ * JSON export. Pairs with hydrate.ts — everything stripped here is restored on import.
+ *
+ * Supports both new `children` shape and legacy `components` shape per column.
+ */
+interface VisibilityConfig {
+    enabled: boolean;
+    match: "all" | "any";
+    rules: unknown[];
+}
+interface BorderConfig {
+    width: number;
+    style: string;
+    color: string;
+    radius?: number;
+}
+interface GradientConfig {
+    useGradient: boolean;
+    solid: string;
+    gradient: {
+        type: "linear" | "radial";
+        direction: string;
+        colors: Array<{
+            color: string;
+            position: number;
+        }>;
+    };
+}
+interface Component {
+    id: string;
+    /** New discriminated shape uses "component"; legacy uses the componentType directly */
+    type: string;
+    /** Present when type === "component" */
+    componentType?: string;
+    props: Record<string, unknown>;
+}
+type CanvasChild = Component | NestedRow | RowSpacer;
+interface Column {
+    id: string;
+    width: number;
+    /** New shape */
+    children?: CanvasChild[];
+    /** Legacy shape — kept for backward compat */
+    components?: Component[];
+    backgroundColor?: string;
+    backgroundGradient?: GradientConfig;
+    backgroundImage?: string;
+    backgroundSize?: string;
+    backgroundPosition?: string;
+    backgroundRepeat?: string;
+    padding?: Record<string, number>;
+    border?: BorderConfig;
+    verticalAlign?: string;
+    [key: string]: unknown;
+}
+export interface NestedRow {
+    id: string;
+    type: "row";
+    name?: string;
+    columns?: Column[];
+    visibility?: VisibilityConfig;
+    border?: BorderConfig;
+    backgroundImage?: string;
+    backgroundSize?: string;
+    backgroundPosition?: string;
+    backgroundRepeat?: string;
+    padding?: Record<string, number>;
+    backgroundGradient?: GradientConfig;
+    minHeight?: number;
+    [key: string]: unknown;
+}
+export interface RowSpacer {
+    id: string;
+    type: "row-spacer";
+    name?: string;
+    height?: number;
+    backgroundColor?: string;
+    backgroundGradient?: GradientConfig;
+    visibility?: VisibilityConfig;
+    [key: string]: unknown;
+}
+type Row = NestedRow | RowSpacer;
+export interface Canvas {
+    language?: string;
+    preheaderText?: string;
+    bodyBackgroundColor?: string;
+    bodyBackgroundImage?: string;
+    bodyBackgroundSize?: string;
+    bodyBackgroundPosition?: string;
+    bodyBackgroundRepeat?: string;
+    backgroundColor?: string;
+    width?: number;
+    padding?: Record<string, number>;
+    mobileBreakpoint?: number;
+    [key: string]: unknown;
+}
+export declare const optimizeCanvas: (canvas: Canvas) => Partial<Canvas>;
+export declare const optimizeRows: (rows: Row[]) => Partial<Row>[];
+export {};

package/dist/composables/emailBuilder/transform/pipeline/optimizeAI.d.ts

@@ -0,0 +1,125 @@
+/**
+ * optimizeAI.ts
+ * AI-facing counterpart to optimize.ts. Strips default/noise values from
+ * rows, columns, components, and canvas before building the snapshot sent
+ * to the AI model — separate pipeline so it can strip more aggressively
+ * than the JSON-export pipeline without the two compromising each other.
+ *
+ * optimize.ts / hydrate.ts are NOT modified by this file and are unaffected.
+ *
+ * Two different kinds of "default" are handled differently, on purpose:
+ *
+ *   - STATELESS style props (margin, padding, border, letterSpacing, ...):
+ *     no "user chose to remove this" meaning attached — just set vs. unset.
+ *     Diffed against each component TYPE's real default via
+ *     useEmailBuilderDefaults(), so this never drifts out of sync the way a
+ *     hardcoded universal check (e.g. "is it all-zero") can for component
+ *     types whose real default isn't zero. The AI doesn't lose anything by
+ *     these being stripped: schemaBlock() in useEmailAIPrompts.ts already
+ *     tells it every prop + its default, independent of what's in the
+ *     snapshot. Snapshot = the diff; schema = the full menu.
+ *
+ *   - SELECTION-style fields (socials platforms, mobile overrides, the icon
+ *     cluster): reflect a deliberate choice, not just set-vs-unset. Mirrored
+ *     EXACTLY from optimize.ts's existing logic, unchanged, so this pipeline
+ *     respects the same choices the export pipeline already does.
+ *
+ * Restoring what gets stripped here needs no new hydrate-side code: hydrate.ts's
+ * hydrateComponent() already deep-merges against each type's real defaults
+ * (via the same useEmailBuilderDefaults()), so it already restores anything
+ * this file strips. See useEmailAISnapshot.ts's existing hydrateAIRows /
+ * hydrateAIRow / hydrateAIComponent — those remain the AI hydration path,
+ * unchanged.
+ */
+interface VisibilityConfig {
+    enabled: boolean;
+    match: "all" | "any";
+    rules: unknown[];
+}
+interface BorderConfig {
+    width: number;
+    style: string;
+    color: string;
+    radius?: number;
+}
+interface GradientConfig {
+    useGradient: boolean;
+    solid: string;
+    gradient: {
+        type: "linear" | "radial";
+        direction: string;
+        colors: Array<{
+            color: string;
+            position: number;
+        }>;
+    };
+}
+interface Component {
+    id: string;
+    type: string;
+    componentType?: string;
+    props: Record<string, unknown>;
+}
+type CanvasChild = Component | NestedRow | RowSpacer;
+interface Column {
+    id: string;
+    width: number;
+    children?: CanvasChild[];
+    components?: Component[];
+    backgroundColor?: string;
+    backgroundGradient?: GradientConfig;
+    backgroundImage?: string;
+    backgroundSize?: string;
+    backgroundPosition?: string;
+    backgroundRepeat?: string;
+    padding?: Record<string, number>;
+    border?: BorderConfig;
+    verticalAlign?: string;
+    [key: string]: unknown;
+}
+interface NestedRow {
+    id: string;
+    type: "row";
+    name?: string;
+    columns?: Column[];
+    visibility?: VisibilityConfig;
+    border?: BorderConfig;
+    backgroundColor?: string;
+    backgroundImage?: string;
+    backgroundSize?: string;
+    backgroundPosition?: string;
+    backgroundRepeat?: string;
+    padding?: Record<string, number>;
+    backgroundGradient?: GradientConfig;
+    minHeight?: number;
+    gap?: number;
+    [key: string]: unknown;
+}
+interface RowSpacer {
+    id: string;
+    type: "row-spacer";
+    name?: string;
+    height?: number;
+    backgroundColor?: string;
+    backgroundGradient?: GradientConfig;
+    visibility?: VisibilityConfig;
+    [key: string]: unknown;
+}
+type Row = NestedRow | RowSpacer;
+interface Canvas {
+    language?: string;
+    preheaderText?: string;
+    bodyBackgroundColor?: string;
+    bodyBackgroundImage?: string;
+    bodyBackgroundSize?: string;
+    bodyBackgroundPosition?: string;
+    bodyBackgroundRepeat?: string;
+    backgroundColor?: string;
+    width?: number;
+    padding?: Record<string, number>;
+    mobileBreakpoint?: number;
+    [key: string]: unknown;
+}
+export declare const optimizeCanvasForAI: (canvas: Canvas) => Partial<Canvas>;
+export declare const optimizeRowsForAI: (rows: Row[]) => Partial<Row>[];
+export {};

package/dist/composables/emailBuilder/types/emailBuilder.d.ts

@@ -0,0 +1,79 @@
+export interface Padding {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface Border {
+    width: number;
+    style: string;
+    color: string;
+    radius: number;
+}
+export interface GradientStop {
+    color: string;
+    position: number;
+}
+export interface Gradient {
+    type: "linear" | "radial";
+    direction: string;
+    colors: GradientStop[];
+}
+export interface BackgroundGradient {
+    useGradient: boolean;
+    solid: string;
+    gradient: Gradient;
+}
+export interface Visibility {
+    [conditionKey: string]: any;
+}
+export type CanvasChild = CanvasComponentNode | CanvasRowNode | CanvasSpacerNode;
+export interface CanvasComponentNode {
+    id: string;
+    type: "component";
+    componentType: string;
+    props: Record<string, any>;
+    visibility?: Visibility;
+}
+export interface CanvasRowNode {
+    id: string;
+    type: "row";
+    name: string;
+    columns: CanvasColumn[];
+    backgroundColor: string;
+    backgroundGradient: BackgroundGradient;
+    backgroundImage?: string;
+    backgroundSize?: string;
+    backgroundPosition?: string;
+    backgroundRepeat?: string;
+    padding: Padding;
+    border: Border;
+    minHeight: number;
+    gap: number;
+    mobileStack: boolean;
+    visibility: Visibility;
+}
+export interface CanvasSpacerNode {
+    id: string;
+    type: "row-spacer";
+    name: string;
+    height: number;
+    backgroundColor: string;
+    backgroundGradient: BackgroundGradient;
+    visibility: Visibility;
+}
+export interface CanvasColumn {
+    id: string;
+    width: number;
+    children: CanvasChild[];
+    backgroundColor: string;
+    backgroundGradient: BackgroundGradient;
+    backgroundImage?: string;
+    backgroundSize?: string;
+    backgroundPosition?: string;
+    backgroundRepeat?: string;
+    padding: Padding;
+    border: Border;
+    verticalAlign: "top" | "middle" | "bottom";
+}
+export type TopLevelRow = CanvasRowNode | CanvasSpacerNode;

package/dist/composables/system/useColor.d.ts

@@ -0,0 +1,26 @@
+type RGB = [number, number, number];
+export declare function useColor(initial?: string): {
+    h: import('vue').Ref<number, number>;
+    s: import('vue').Ref<number, number>;
+    v: import('vue').Ref<number, number>;
+    a: import('vue').Ref<number, number>;
+    rgb: import('vue').ComputedRef<RGB>;
+    hex: import('vue').ComputedRef<string>;
+    rgba: import('vue').ComputedRef<string>;
+    cssColor: import('vue').ComputedRef<string>;
+    hsl: import('vue').ComputedRef<{
+        h: number;
+        s: number;
+        l: number;
+    }>;
+    hsb: import('vue').ComputedRef<{
+        h: number;
+        s: number;
+        b: number;
+    }>;
+    setFromHex: (hexVal: string) => boolean;
+    setFromRgb: (r: number, g: number, b: number) => void;
+    setFromHsl: (hh: number, ss: number, ll: number) => void;
+    setFromHsb: (hh: number, ss: number, bb: number) => void;
+};
+export {};

package/dist/composables/system/useDeviceDetection.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'vue';
+export declare const useDeviceDetection: () => {
+    isDesktop: Ref<boolean, boolean>;
+    isMobile: import('vue').ComputedRef<boolean>;
+};

package/dist/composables/system/useGoogleFonts.d.ts

@@ -0,0 +1,11 @@
+export declare const useGoogleFonts: () => {
+    googleFonts: import('vue').Ref<string[], string[]>;
+    loadGoogleFont: (fontFamily?: string) => void;
+    getGoogleFontImports: (fonts: string[]) => string;
+    syncFontsForTemplate: (fonts: string[]) => void;
+    preconnectGoogleFonts: () => void;
+    isWebSafeFont: (font: string) => boolean;
+    WEB_SAFE_FONTS: Set<string>;
+    FONTS_WITH_ITALICS: Set<string>;
+    DEFAULT_WEIGHTS: number[];
+};

package/dist/composables/system/useImageUpload.d.ts

@@ -0,0 +1,23 @@
+export interface UploadResult {
+    previewUrl: string;
+    permanentUrl: string;
+    cleanup: () => void;
+}
+export declare class ImageUploadError extends Error {
+    constructor(message: string);
+}
+export declare function validateImageFile(file: File): void;
+export declare function swapOnLoad(permanentUrl: string, onReady: () => void, cleanup: () => void): void;
+/**
+ * Called from within a component's setup — useStorageAdapter() requires
+ * that timing, which is why this is a composable rather than a plain
+ * export like the three functions above (none of which need injection).
+ *
+ * Returns handleImageUploadFlow pre-bound to the active adapter, so call
+ * sites keep the exact same 4-argument call shape they always had.
+ */
+export declare function useImageUploader(): {
+    handleImageUploadFlow: (file: File, onPreview: (objectUrl: string) => void, onSuccess: (permanentUrl: string, cleanup: () => void) => void, onError: (message: string) => void) => Promise<void>;
+    swapOnLoad: typeof swapOnLoad;
+    validateImageFile: typeof validateImageFile;
+};

package/dist/composables/system/useSavedRowsPanel.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared open/close state for the Saved Rows panel.
+ *
+ * this used to be Nuxt's useState, shared across components by
+ * matching string key. Same provide/inject conversion as useEmailBuilder —
+ * one instance created at the EmailEditor root, injected everywhere else,
+ * so LayoutTab's toggle button and SavedRowsPanel's isOpen check still see
+ * the same boolean.
+ *
+ * The "system" tab concept was removed from SavedRowsPanel.vue
+ * (see its top-of-file note) — activeTab is kept here since LayoutTab still
+ * references the shape, but it's permanently "user" now in practice.
+ */
+export type SavedRowsTab = "user" | "system";
+type SavedRowsPanelInstance = ReturnType<typeof createSavedRowsPanelInstance>;
+/** Called once, at the EmailEditor root. */
+export declare function provideSavedRowsPanel(): {
+    isOpen: import('vue').Ref<boolean, boolean>;
+    activeTab: import('vue').Ref<SavedRowsTab, SavedRowsTab>;
+    open: (tab?: SavedRowsTab) => void;
+    close: () => void;
+    toggle: (tab?: SavedRowsTab) => void;
+    setTab: (tab: SavedRowsTab) => void;
+};
+/** Every other file calls this exactly as before. */
+export declare const useSavedRowsPanel: () => SavedRowsPanelInstance;
+declare function createSavedRowsPanelInstance(): {
+    isOpen: import('vue').Ref<boolean, boolean>;
+    activeTab: import('vue').Ref<SavedRowsTab, SavedRowsTab>;
+    open: (tab?: SavedRowsTab) => void;
+    close: () => void;
+    toggle: (tab?: SavedRowsTab) => void;
+    setTab: (tab: SavedRowsTab) => void;
+};
+export {};

package/dist/composables/ui/useConfirm.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Confirmation dialog store.
+ *
+ * Module-level singleton state rather than provide/inject, deliberately.
+ * An injected service has two failure modes this avoids: it can't be read
+ * from the same component that provides it (Vue's inject() never sees the
+ * current component's own provide()), and two copies of the providing
+ * module produce two different injection keys for what should be one
+ * store. A module-scoped ref has neither problem — one store, no keys, no
+ * dependency on where in the tree the caller sits — so it behaves
+ * identically however the editor is mounted.
+ */
+export interface ConfirmOptions {
+    message?: string;
+    header?: string;
+    acceptLabel?: string;
+    rejectLabel?: string;
+    acceptClass?: string;
+    rejectClass?: string;
+    accept?: () => void;
+    reject?: () => void;
+}
+/** Null when nothing is pending — ConfirmDialog.vue renders on this. */
+export declare const activeConfirm: import('vue').ShallowRef<ConfirmOptions | null, ConfirmOptions | null>;
+export declare const confirmVisible: import('vue').Ref<boolean, boolean>;
+declare function close(): void;
+export declare function acceptActive(): void;
+export declare function rejectActive(): void;
+export declare function useConfirm(): {
+    require(options: ConfirmOptions): void;
+    close: typeof close;
+};
+export {};