import { A11yOptions } from '../../quality/src/index.ts';
import { A11yOptions as A11yOptions_2 } from '../../../quality/src/index.ts';
import { AiConfig } from '../../../types/src/index.ts';
import { BlockDefaults } from '../../types/src/index.ts';
import { BlockDefaults as BlockDefaults_2 } from '../../../types/src/index.ts';
import { CollaborationConfig } from '../../../types/src/index.ts';
import { CommentEvent } from '../../../types/src/index.ts';
import { ComputedRef } from 'vue';
import { CustomBlock } from '../../types/src/index.ts';
import { CustomBlockDefinition } from '../../types/src/index.ts';
import { CustomBlockDefinition as CustomBlockDefinition_2 } from '../../../types/src/index.ts';
import { CustomFont } from '../../types/src/index.ts';
import { CustomFont as CustomFont_2 } from '../../../types/src/index.ts';
import { DisplayConditionsConfig } from '../../types/src/index.ts';
import { DisplayConditionsConfig as DisplayConditionsConfig_2 } from '../../../types/src/index.ts';
import { FontsConfig } from '../../types/src/index.ts';
import { FontsConfig as FontsConfig_2 } from '../../../types/src/index.ts';
import { McpConfig } from '../../../types/src/index.ts';
import { MediaItem } from '../../../media-library/src/index.ts';
import { MediaRequestContext } from '../../media-library/src/index.ts';
import { MediaRequestContext as MediaRequestContext_2 } from '../../../media-library/src/index.ts';
import { MediaResult } from '../../types/src/index.ts';
import { MergeTagsConfig } from '../../types/src/index.ts';
import { MergeTagsConfig as MergeTagsConfig_2 } from '../../../types/src/index.ts';
import { Ref } from 'vue';
import { SaveResult } from '../../types/src/index.ts';
import { SaveResult as SaveResult_2 } from '../../../types/src/index.ts';
import { Template } from '../../types/src/index.ts';
import { Template as Template_2 } from '../../../types/src/index.ts';
import { TemplateContent } from '../../types/src/index.ts';
import { TemplateContent as TemplateContent_2 } from '../../../types/src/index.ts';
import { TemplateDefaults } from '../../types/src/index.ts';
import { TemplateDefaults as TemplateDefaults_2 } from '../../../types/src/index.ts';
import { ThemeOverrides } from '../../types/src/index.ts';
import { ThemeOverrides as ThemeOverrides_2 } from '../../../types/src/index.ts';
import { UiTheme } from '../../types/src/index.ts';
import { UiTheme as UiTheme_2 } from '../../../types/src/index.ts';
import { ViewportSize } from '../../types/src/index.ts';

export { BlockDefaults }

export { CustomBlockDefinition }

export { CustomFont }

export declare const DEFAULT_EDITOR_TOUR_STORAGE_KEY = "templatical-editor-tour-dismissed";

export { DisplayConditionsConfig }

export declare interface EditorCapabilities {
    plan?: {
        hasFeature(feature: string): boolean;
    };
    ai?: {
        isFeatureEnabled(feature: string): boolean;
    };
    comments?: {
        getBlockCount(blockId: string): number;
        openForBlock(blockId: string): void;
    };
    savedModules?: {
        openSaveDialog(blockId: string): void;
        openBrowser(): void;
        moduleCount: ComputedRef<number>;
    };
}

export declare interface EditorTourConfig {
    /**
     * Steps to show in order. Omit to use built-in defaults (canvas, block rail, right sidebar).
     */
    steps?: EditorTourStep[];
    /** Start automatically after mount when the tour has not been dismissed. Default `false`. */
    autoStart?: boolean;
    /**
     * `localStorage` key for dismissal persistence.
     * Set to `false` to disable persistence (tour can restart every load).
     * Default key is `DEFAULT_EDITOR_TOUR_STORAGE_KEY` when omitted.
     */
    storageKey?: string | false;
}

export declare interface EditorTourStartOptions {
    /** Zero-based index into the active (filtered) step list */
    stepIndex?: number;
}

export declare interface EditorTourStep {
    /** Any valid `document.querySelector` selector (editor internals or host DOM). */
    target: string;
    title: string;
    text: string;
    placement?: EditorTourStepPlacement;
    /**
     * When the target is absent, skip this step. Default `true`.
     * Set `false` to keep the step even if the node is missing (rect will be null — avoided).
     */
    skipIfMissing?: boolean;
}

/**
 * Guided tour types for Templatical Editor `init()` / `initCloud()`.
 */
/** Reserved tooltip placement hints for layout inside the viewport. */
export declare type EditorTourStepPlacement = "canvas" | "sidebar" | "rightSidebar" | "below";

/** Email vs popup builder chrome (sidebar layout). */
export declare type EditorType = "email" | "popup";

export declare interface FontOption {
    value: string;
    label: string;
    isCustom?: boolean;
}

export { FontsConfig }

export declare function init(config: TemplaticalEditorConfig): Promise<TemplaticalEditor>;

export declare function initCloud(config: TemplaticalCloudEditorConfig): Promise<TemplaticalCloudEditor>;

export { MergeTagsConfig }

/** Function type for media browser requests, used by both OSS and Cloud editors. */
export declare type OnRequestMedia = (context?: MediaRequestContext) => Promise<MediaResult | null>;

export { SaveResult }

export { Template }

export { TemplateContent }

export { TemplateDefaults }

/**
 * Cloud editor does not expose `toMjml` or `renderCustomBlock`: the cloud
 * backend performs MJML conversion server-side with additional processing
 * (e.g., signed image URLs, attachment handling) that isn't available client
 * side. Use the cloud `save()` flow to persist content; the backend handles
 * MJML/HTML export from there.
 */
export declare interface TemplaticalCloudEditor extends TemplaticalEditorBase {
    create(content?: TemplateContent): Promise<Template>;
    load(templateId: string): Promise<Template>;
    save(): Promise<SaveResult>;
}

export declare interface TemplaticalCloudEditorConfig {
    container: string | HTMLElement;
    content?: TemplateContent_2;
    auth: {
        url: string;
        baseUrl?: string;
        requestOptions?: {
            method?: "GET" | "POST";
            headers?: Record<string, string>;
            body?: Record<string, unknown>;
            credentials?: RequestCredentials;
        };
    };
    theme?: ThemeOverrides_2;
    uiTheme?: UiTheme_2;
    locale?: string;
    /**
     * Show the "Powered by Templatical" footer. Defaults to `true`.
     * Set to `false` to hide the footer (no attribution required by the license).
     * Cloud white-label plans hide the footer regardless of this setting.
     */
    branding?: boolean;
    /**
     * Multi-step canvas for popup-style flows. See {@link TemplaticalEditorConfig.multiPageCanvas}.
     */
    multiPageCanvas?: boolean;
    /**
     * Same semantics as {@link TemplaticalEditorConfig.editorType} (popup adds icon rail).
     */
    editorType?: EditorType | string;
    ai?: AiConfig | false;
    commenting?: boolean;
    collaboration?: CollaborationConfig;
    mcp?: McpConfig;
    blockDefaults?: BlockDefaults_2;
    templateDefaults?: TemplateDefaults_2;
    modules?: boolean;
    autoSave?: boolean;
    autoSaveDebounce?: number;
    mergeTags?: MergeTagsConfig_2;
    displayConditions?: DisplayConditionsConfig_2;
    customBlocks?: CustomBlockDefinition_2[];
    fonts?: FontsConfig_2;
    onChange?: (content: TemplateContent_2) => void;
    onSave?: (result: SaveResult_2) => void;
    onCreate?: (template: Template_2) => void;
    onLoad?: (template: Template_2) => void;
    onError?: (error: Error) => void;
    onComment?: (event: CommentEvent) => void;
    onUnmount?: () => void;
    onRequestMedia?: (context: MediaRequestContext_2) => Promise<MediaItem | null>;
    onBeforeTestEmail?: (html: string) => string | Promise<string>;
    /**
     * Accessibility linter (`@aswin.dev/quality`) configuration. Cloud
     * additionally merges `planConfig.accessibility` from the server (server
     * policy wins on conflict) — this option sets the consumer-supplied baseline.
     */
    accessibility?: A11yOptions_2;
    /** Optional guided tour (same shape as the OSS editor `tour` option). */
    tour?: EditorTourConfig;
}

export declare interface TemplaticalEditor extends TemplaticalEditorBase {
    /**
     * Render the current template to an MJML string. Resolves custom blocks
     * via the editor's internal block registry. Throws if the optional
     * `@aswin.dev/renderer` package is not installed.
     */
    toMjml(): Promise<string>;
    /**
     * Render a single custom block to its HTML representation, using the
     * registered custom block definition's template and the block's current
     * field values. Exposed for headless callers that want to reuse the
     * editor's renderer (e.g., to drive `@aswin.dev/renderer`'s
     * `renderCustomBlock` option from outside the editor instance).
     */
    renderCustomBlock(block: CustomBlock): Promise<string>;
}

declare interface TemplaticalEditorBase {
    getContent(): TemplateContent;
    setContent(content: TemplateContent): void;
    setTheme(theme: UiTheme): void;
    unmount(): void;
    /** Requires `tour` in editor config; otherwise no-ops. */
    startTour(options?: EditorTourStartOptions): void;
    dismissTour(): void;
    resetTourDismissed(): void;
    /** `true` when no tour is configured or the user dismissed a persisted tour. */
    isTourDismissed(): boolean;
    /**
     * Undo the last canvas/template change (same stack as toolbar and Cmd/Ctrl+Z).
     * Rich text fields use TipTap’s own undo while focused.
     */
    undo(): void;
    /** Redo (same stack as toolbar and Cmd/Ctrl+Shift+Z). */
    redo(): void;
    /** Whether a canvas/template undo is available. */
    canUndo(): boolean;
    /** Whether redo is available. */
    canRedo(): boolean;
}

export declare interface TemplaticalEditorConfig {
    container: string | HTMLElement;
    content?: TemplateContent;
    onChange?: (content: TemplateContent) => void;
    onSave?: (content: TemplateContent) => void;
    onError?: (error: Error) => void;
    onRequestMedia?: OnRequestMedia;
    mergeTags?: MergeTagsConfig;
    displayConditions?: DisplayConditionsConfig;
    customBlocks?: CustomBlockDefinition[];
    fonts?: FontsConfig;
    blockDefaults?: BlockDefaults;
    templateDefaults?: TemplateDefaults;
    theme?: ThemeOverrides;
    uiTheme?: UiTheme;
    locale?: string;
    /**
     * Show the "Powered by Templatical" footer. Defaults to `true`.
     * Set to `false` to hide the footer (no attribution required by the license).
     */
    branding?: boolean;
    /**
     * Multi-step canvas (popup flows): step strip above the canvas; content exposes
     * {@link TemplateContent.canvasPages} and {@link TemplateContent.activeCanvasPageId}.
     */
    multiPageCanvas?: boolean;
    /**
     * `'email'` (default): single hover-expand block rail. `'popup'`: adds a left icon rail
     * (Design, Blocks, Tab, …) beside the same block palette when Blocks is selected.
     * The value is provided through `EDITOR_TYPE_KEY`. Case-insensitive strings such as
     * `'POPUP'` are accepted.
     */
    editorType?: EditorType | string;
    /**
     * Accessibility linter (`@aswin.dev/quality`) configuration.
     *
     * - When unset, the linter loads on demand once the user opens the panel.
     * - When `disabled: true`, the optional peer is never imported (saves the
     *   chunk download) and the sidebar tab + inline badges are suppressed.
     * - `rules`/`thresholds` follow the shape exported by `@aswin.dev/quality`.
     */
    accessibility?: A11yOptions;
    /**
     * Optional spotlight tour (inside or outside the editor DOM via selectors).
     * Use `startTour` / `isTourDismissed` on the instance; default copy lives under locale `tour.defaults`.
     */
    tour?: EditorTourConfig;
}

export { ThemeOverrides }

export { UiTheme }

export declare function unmount(): void;

export declare function useFonts(config?: FontsConfig_2): UseFontsReturn;

export declare interface UseFontsReturn {
    fonts: ComputedRef<FontOption[]>;
    defaultFont: ComputedRef<string>;
    defaultFallback: ComputedRef<string>;
    customFonts: Ref<CustomFont_2[]>;
    customFontsEnabled: Ref<boolean>;
    isLoaded: Ref<boolean>;
    setCustomFontsEnabled: (enabled: boolean) => void;
    loadCustomFonts: () => Promise<void>;
    cleanupFontLinks: () => void;
    getFontWithFallback: (fontName: string) => string;
    getDefaultFont: () => string;
}

export { ViewportSize }

export { }


declare module "@tiptap/core" {
    interface Commands<ReturnType> {
        lineHeight: {
            setLineHeight: (lineHeight: string) => ReturnType;
            unsetLineHeight: () => ReturnType;
        };
    }
}


declare module "@tiptap/core" {
    interface Commands<ReturnType> {
        mergeTagNode: {
            insertMergeTag: (attrs: MergeTag) => ReturnType;
        };
    }
}


declare module "@tiptap/core" {
    interface Commands<ReturnType> {
        fontSize: {
            setFontSize: (size: string) => ReturnType;
            unsetFontSize: () => ReturnType;
        };
    }
}


declare module "@tiptap/core" {
    interface Commands<ReturnType> {
        letterSpacing: {
            setLetterSpacing: (spacing: string) => ReturnType;
            unsetLetterSpacing: () => ReturnType;
        };
    }
}