import { Editor, Extension } from '@tiptap/core';

/** Layout attrs shared by node options, live DOM, and export HTML. */
type StyleLayoutOptions = {
    width?: number | string | null;
    height?: number | string | null;
    float?: string | null;
    clear?: string | null;
    margin?: string | null;
    display?: string | null;
    justifyContent?: string | null;
};

interface NodeOptions$1 {
    HTMLAttributes: Record<string, unknown>;
}
interface AudioOptions extends StyleLayoutOptions, NodeOptions$1 {
    inline?: boolean;
    controls?: boolean;
    autoplay?: boolean;
    loop?: boolean;
    muted?: boolean;
    preload?: 'none' | 'metadata' | 'auto';
    src: string | null;
}
type SetAudioOptions = {
    src: string;
    controls?: boolean;
    autoplay?: boolean;
    loop?: boolean;
    muted?: boolean;
    preload?: 'none' | 'metadata' | 'auto';
} & StyleLayoutOptions;

interface ImageLayoutOptions {
    width?: number | null;
    height?: number | null;
    margin?: string;
    clear?: string;
    float?: string | null;
    display?: string;
}
interface ImageNodeOptions {
    HTMLAttributes: Record<string, any>;
}
interface ImageOptions extends ImageLayoutOptions, ImageNodeOptions {
    allowBase64: boolean;
    /** Render as inline element instead of block */
    inline: boolean;
}
type SetImageOptions = {
    src: string;
    alt?: string;
    title?: string;
    /** Caption rendered under the image (markdown export drops it — documented lossy contract) */
    caption?: string;
} & ImageLayoutOptions;
interface UpdateImageDimensionsParams {
    keyId: string;
    width?: number | null;
    height?: number | null;
}

interface EmbedNodeOptions {
    inline: boolean;
    addPasteHandler: boolean;
    HTMLAttributes: Record<string, unknown>;
}
interface FullscreenIframeKitOptions {
    allow: string;
    frameborder: number;
    allowfullscreen: boolean;
}

interface LoomEmbedKitOptions {
    autoplay: 0 | 1;
    muted: 0 | 1;
    hideOwner: boolean;
    hideShare: boolean;
    hideTitle: boolean;
    hideEmbedTopBar: boolean;
    allow: string;
    frameborder: number;
    allowfullscreen: boolean;
    scrolling: string;
}

interface LoomOptions extends StyleLayoutOptions, EmbedNodeOptions, LoomEmbedKitOptions {
}
type SetLoomOptions = {
    src: string;
} & StyleLayoutOptions & Partial<LoomEmbedKitOptions>;

/** SoundCloud HTML5 widget params — [widget docs](https://developers.soundcloud.com/docs/api/html5-widget). */
interface SoundCloudPlayerKitOptions {
    auto_play: boolean;
    hide_related: boolean;
    show_comments: boolean;
    show_user: boolean;
    show_reposts: boolean;
    visual: boolean;
    color?: string;
    buying: boolean;
    sharing: boolean;
    download: boolean;
    show_artwork: boolean;
    show_playcount: boolean;
    start_track?: number;
    single_active: boolean;
    scrolling: string;
    frameborder: string;
    allow: string;
}

interface SoundCloudOptions extends StyleLayoutOptions, EmbedNodeOptions, SoundCloudPlayerKitOptions {
}
type SetSoundCloudOptions = {
    src: string;
} & StyleLayoutOptions & Partial<SoundCloudPlayerKitOptions>;

/** Embeddable Spotify entities — the `{type}` segment of an `open.spotify.com` URL. */
type SpotifyEntityType = 'track' | 'album' | 'playlist' | 'artist' | 'show' | 'episode';
declare const SPOTIFY_ENTITY_TYPES: readonly ["track", "album", "playlist", "artist", "show", "episode"];
/** Spotify's two embed themes — `0` dark (default), `1` light. No other values exist. */
type SpotifyTheme = 0 | 1;
/**
 * Resolve a Spotify share URL or `spotify:` URI to its `{ type, id }`, or null.
 * Accepts `open.spotify.com/{type}/{id}`, localized `intl-xx`, already-`embed`
 * paths, and `spotify:type:id` URIs; rejects every other host (exact match).
 */
declare const parseSpotifyEntity: (input: string) => {
    type: SpotifyEntityType;
    id: string;
} | null;
interface SpotifyEmbedKitOptions extends FullscreenIframeKitOptions {
    /** `0` dark / `1` light. Unset uses Spotify's default (dark). */
    theme?: SpotifyTheme;
}

interface SpotifyOptions extends StyleLayoutOptions, EmbedNodeOptions, SpotifyEmbedKitOptions {
}
type SetSpotifyOptions = {
    src: string;
} & StyleLayoutOptions & Partial<SpotifyEmbedKitOptions>;

interface NodeOptions {
    HTMLAttributes: Record<string, unknown>;
}
interface VideoOptions extends StyleLayoutOptions, NodeOptions {
    inline?: boolean;
    controls?: boolean;
    autoplay?: boolean;
    loop?: boolean;
    muted?: boolean;
    poster?: string | null;
    preload?: 'none' | 'metadata' | 'auto';
    src: string | null;
}
type SetVideoOptions = {
    src: string;
    controls?: boolean;
    autoplay?: boolean;
    loop?: boolean;
    muted?: boolean;
    poster?: string | null;
    preload?: 'none' | 'metadata' | 'auto';
} & StyleLayoutOptions;

/** Kit defaults and node attrs merged into Vimeo player iframe query params. */
type VimeoBylinePortrait = boolean | 'site-default';
type VimeoQuality = '240p' | '360p' | '540p' | '720p' | '1080p' | '2k' | '4k' | 'auto';
interface VimeoPlayerKitOptions {
    autopause: boolean;
    autoplay: boolean;
    background: boolean;
    byline: VimeoBylinePortrait;
    color?: string;
    controls: boolean;
    dnt: boolean;
    keyboard: boolean;
    loop: boolean;
    muted: boolean;
    pip: boolean;
    playsinline: boolean;
    portrait: VimeoBylinePortrait;
    quality: VimeoQuality;
    speed: boolean;
    texttrack?: string | false;
    title: boolean;
    transparent: boolean;
    endTime?: number;
    allow: string;
    frameborder: number;
    allowfullscreen: boolean;
}

interface VimeoOptions extends StyleLayoutOptions, EmbedNodeOptions, VimeoPlayerKitOptions {
}
type SetVimeoOptions = {
    src: string;
    start?: number;
} & StyleLayoutOptions & Partial<VimeoPlayerKitOptions>;

type XEmbedSizeId = 'compact' | 'standard' | 'wide';
type XEmbedTheme = 'light' | 'dark';
declare const X_EMBED_DEFAULT_MAXWIDTH = 400;
declare const X_EMBED_SIZE_OPTIONS: ReadonlyArray<{
    id: XEmbedSizeId;
    label: string;
    maxwidth: number;
}>;
declare const X_EMBED_THEME_OPTIONS: ReadonlyArray<{
    id: XEmbedTheme;
    label: string;
}>;
declare const resolveXEmbedSizeId: (maxwidth: number | null | undefined) => XEmbedSizeId;
interface XOEmbedKitOptions {
    theme: XEmbedTheme;
    lang: string;
    dnt: boolean;
    hide_media: boolean;
    hide_thread: boolean;
}
declare const buildXOEmbedParams: (attrs: Record<string, unknown>, options: XOEmbedKitOptions) => Record<string, string | number>;

interface XOptions extends StyleLayoutOptions, EmbedNodeOptions, XOEmbedKitOptions {
}
type AddXOptions = {
    src: string;
    maxwidth?: number;
    theme?: XEmbedTheme;
    lang?: string;
    hide_media?: boolean;
    hide_thread?: boolean;
} & StyleLayoutOptions;

/** Kit defaults and node attrs merged into official YouTube iframe query params. */
type YoutubeEmbedColor = 'red' | 'white';
type YoutubeListType = 'playlist' | 'user_uploads';
interface YoutubePlayerKitOptions {
    autoplay: 0 | 1;
    ccLanguage?: string;
    ccLoadPolicy?: 0 | 1;
    color?: YoutubeEmbedColor;
    controls: 0 | 1;
    disableKBcontrols: 0 | 1;
    enableIFrameApi: 0 | 1;
    endTime?: number;
    fs: 0 | 1;
    interfaceLanguage?: string;
    ivLoadPolicy: 1 | 3;
    loop: 0 | 1;
    modestbranding: 0 | 1;
    nocookie: boolean;
    origin?: string;
    playlist?: string;
    playsinline: 0 | 1;
    rel: 0 | 1;
    list?: string;
    listType?: YoutubeListType;
    allow: string;
    frameborder: number;
    allowfullscreen: boolean;
}
declare const parseYoutubeVideoId: (url: string) => string | null;

interface YoutubeOptions extends StyleLayoutOptions, EmbedNodeOptions, YoutubePlayerKitOptions {
}
type SetYoutubeVideoOptions = {
    src: string;
    start?: number;
} & StyleLayoutOptions & Partial<YoutubePlayerKitOptions>;

/** Every public command the media nodes contribute, in one place. */
interface MediaPublicCommands<ReturnType> {
    /** Insert an image node; mints a fresh `keyId` per insert. */
    setImage: (options: SetImageOptions) => ReturnType;
    /** Set the `width` / `height` attributes of an existing image by `keyId`. */
    updateImageDimensions: (options: UpdateImageDimensionsParams) => ReturnType;
    /** Insert a `<video>` node; returns `false` without a `src`. */
    setVideo: (options: SetVideoOptions) => ReturnType;
    /** Insert an `<audio>` node; returns `false` without a `src`. */
    setAudio: (options: SetAudioOptions) => ReturnType;
    /** Insert a YouTube embed; returns `false` for an invalid URL. */
    setYoutubeVideo: (options: SetYoutubeVideoOptions) => ReturnType;
    /** Insert a Vimeo embed; returns `false` for an invalid URL. */
    setVimeo: (options: SetVimeoOptions) => ReturnType;
    /** Insert a SoundCloud embed; returns `false` for an invalid URL. */
    setSoundCloud: (options: SetSoundCloudOptions) => ReturnType;
    /** Insert a Spotify embed; returns `false` for an invalid URL. */
    setSpotify: (options: SetSpotifyOptions) => ReturnType;
    /** Insert an X embed; returns `false` for an invalid URL. */
    setX: (options: AddXOptions) => ReturnType;
    /** Insert a Loom embed; returns `false` for an invalid URL. */
    setLoom: (options: SetLoomOptions) => ReturnType;
}
declare module '@tiptap/core' {
    interface Commands<ReturnType> {
        media: MediaPublicCommands<ReturnType>;
    }
}

/** Persisted doc unchanged — loading UI is node-view shell only. */
type MediaLoadingKind = 'image' | 'video' | 'audio' | 'embed';
interface MediaLoadingShellContext {
    kind: MediaLoadingKind;
    width: number;
    height: number;
    /** Shown in the default shell, e.g. "YouTube", "X". */
    provider?: string;
    message?: string;
}
/** Include `.hm-loading-shell__message` if `markError` should update visible text. */
type MediaLoadingShellFactory = (context: MediaLoadingShellContext) => HTMLElement;
/** `true` = built-in shell; `false` = off; function = custom overlay root. */
type MediaLoadingShellOption = boolean | MediaLoadingShellFactory;
interface MediaLoadingBindLoadOptions {
    element: HTMLElement;
    /** Defaults to always false — waits for element load/error events. */
    isAlreadyReady?: () => boolean;
}
interface MediaLoadingShellWrapOptions {
    /** Auto-settle via media element load/error; omit for manual (e.g. X oEmbed). */
    bindLoad?: MediaLoadingBindLoadOptions;
    /** When set, used instead of the generic responsive host sync on mount. */
    syncLoadingHost?: (el: HTMLElement, width: number, height: number) => void;
}
interface MediaLoadingController {
    markReady: () => void;
    markError: (message?: string) => void;
    destroy: () => void;
}

declare function wrapMediaWithLoadingShell(editor: Editor, context: MediaLoadingShellContext, content: HTMLElement, options?: MediaLoadingShellWrapOptions): {
    dom: HTMLElement;
    controller: MediaLoadingController;
};

declare function createDefaultMediaLoadingShell(context: MediaLoadingShellContext): HTMLElement;

type MediaActionPlacement = 'inline' | 'overflow';
/** Everything an action needs to read state and mutate the node. Built per open. */
interface MediaActionContext {
    editor: Editor;
    nodeType: string;
    nodePos: number;
    /** Node attrs snapshotted at toolbar-open. Attr-mutating picks tear the bar down (see createMediaToolbar), so a re-hover always rebuilds with fresh attrs — no live getter needed. */
    attrs: Record<string, unknown>;
    /** The media wrapper element that hosts the toolbar (`.hypermultimedia--<type>__content`). */
    wrapper: HTMLElement;
    /** Dismiss any open menu/submenu popover (not the in-place bar — the controls layer owns that). */
    close: () => void;
}
interface MediaAction {
    id: string;
    label: (ctx: MediaActionContext) => string;
    /** Optional one-off SVG override; omit on custom bricks and use `mediaToolbarIcons` by `id`. */
    icon?: (ctx: MediaActionContext) => string | null;
    placement: MediaActionPlacement;
    /** Hidden entirely when this returns false. Default: shown. */
    isVisible?: (ctx: MediaActionContext) => boolean;
    isActive?: (ctx: MediaActionContext) => boolean;
    /** Direct click handler. Mutually exclusive with `renderSubmenu`. */
    run?: (ctx: MediaActionContext) => void;
    /** Builds a submenu body (alignment, margin presets, X size/theme). Inline → popover; overflow → expanded row. */
    renderSubmenu?: (ctx: MediaActionContext) => HTMLElement;
    /** Inline only: render a separator after this action to group it apart from the rest of the bar. */
    dividerAfter?: boolean;
}
type MediaActionList = MediaAction[];
/** Host hook to add, remove, or reorder the resolved actions for a node. */
type MediaActionsResolver = (defaults: MediaActionList, ctx: {
    nodeType: string;
}) => MediaActionList;
interface MediaToolbarOptions {
    /** The media wrapper element (toolbar mounts inside it, top-right). */
    target: HTMLElement;
    editor: Editor;
    nodeType: string;
    /** Snapshot at toolbar-open. The built-in bar's context is refreshed as content shifts; custom factories must re-resolve at action time (e.g. `resolveMediaNodePos`). */
    nodePos: number;
}
/** Return an element for the desktop overlay, or `null` so the host renders its own surface. */
type MediaToolbarFactory = (options: MediaToolbarOptions) => HTMLElement | null;

/** Contract handed to a `replaceUrlPopover` factory. `nodePos` is a snapshot at open; `apply` re-validates, commits the normalized URL, and closes. */
interface ReplaceUrlPopoverOptions {
    editor: Editor;
    nodeType: string;
    nodePos: number;
    /** Current `src`, for prefilling the editor UI. */
    src: string;
    /** Error message for an invalid URL, `null` when it passes the node's guard. */
    validate: (url: string) => string | null;
    apply: (url: string) => void;
    close: () => void;
}
/** Return the popover content, or `null` to opt out so the host renders its own surface. */
type ReplaceUrlPopoverFactory = (options: ReplaceUrlPopoverOptions) => HTMLElement | null;
/** Prebuilt popover content: prefilled URL field, Replace confirm, inline error. */
declare const createReplaceUrlPopover: ReplaceUrlPopoverFactory;
/** Open the URL editor in a dialog popover anchored to the media node (bottom, flipping to top). A `replaceUrlPopover` factory returning `null` opts out entirely. */
declare function openReplaceUrlPopover(ctx: MediaActionContext): void;

declare const MEDIA_MARGIN_OPTIONS: readonly [{
    readonly value: "0in";
    readonly label: "0\"";
}, {
    readonly value: "0.06in";
    readonly label: "1/16\"";
}, {
    readonly value: "0.13in";
    readonly label: "1/8\"";
}, {
    readonly value: "0.25in";
    readonly label: "1/4\"";
}, {
    readonly value: "0.38in";
    readonly label: "3/8\"";
}, {
    readonly value: "0.5in";
    readonly label: "1/2\"";
}, {
    readonly value: "0.75in";
    readonly label: "3/4\"";
}, {
    readonly value: "1in";
    readonly label: "1\"";
}];
type MediaPlacementId = 'inline' | 'center' | 'right' | 'float-left' | 'float-right';
declare const MEDIA_PLACEMENT_OPTIONS: ReadonlyArray<{
    id: MediaPlacementId;
    label: string;
}>;
declare function getMediaPlacementAttrs(id: MediaPlacementId, margin?: string): Record<string, string>;
declare function getCurrentMediaPlacement(attrs: Record<string, unknown>): MediaPlacementId;

type BuiltinIconKey = 'caption' | 'view-original' | 'download' | 'replace' | 'copy' | 'delete' | 'more';
type PlacementIconKey = `align:${MediaPlacementId}`;
/** A built-in slot, an `align:<placement>` slot, or a custom action id from `mediaActions`. */
type MediaToolbarIconKey = BuiltinIconKey | PlacementIconKey | (string & {});
/** Everything a host needs to pick an icon — the key encodes the dynamic part. */
interface MediaToolbarIconContext {
    key: MediaToolbarIconKey;
    nodeType: string;
}
/** Host hook: return SVG markup for a slot, or nullish to keep the built-in icon. */
type MediaToolbarIconsResolver = (ctx: MediaToolbarIconContext) => string | null | undefined;

interface HyperMultimediaKitOptions {
    Image: Partial<ImageOptions & {
        resizeGripper?: boolean;
    }> | true | false;
    Audio: Partial<AudioOptions & {
        resizeGripper?: boolean;
    }> | true | false;
    Video: Partial<VideoOptions & {
        resizeGripper?: boolean;
    }> | true | false;
    Youtube: Partial<YoutubeOptions & {
        resizeGripper?: boolean;
    }> | true | false;
    Vimeo: Partial<VimeoOptions & {
        resizeGripper?: boolean;
    }> | true | false;
    SoundCloud: Partial<SoundCloudOptions & {
        resizeGripper?: boolean;
    }> | true | false;
    Spotify: Partial<SpotifyOptions & {
        resizeGripper?: boolean;
    }> | true | false;
    Loom: Partial<LoomOptions & {
        resizeGripper?: boolean;
    }> | true | false;
    X: Partial<XOptions> | true | false;
    /**
     * Host-agnostic toolbar slot. Return an element for the desktop floating
     * toolbar or `null` to opt out so the host renders its own surface (mobile
     * sheet). Omit to use the built-in `createMediaToolbar`.
     */
    mediaToolbar?: MediaToolbarFactory;
    /**
     * Loading overlay while remote media / embeds resolve. `true` = built-in
     * shimmer shell; `false` = off; pass a factory to replace the overlay UI only.
     */
    loadingShell?: MediaLoadingShellOption;
    /** Customize/extend/reorder the built-in toolbar actions per node. */
    mediaActions?: MediaActionsResolver;
    /**
     * Swap toolbar/menu SVG markup by icon key (`caption`, `more`, `align:center`,
     * custom action ids) without replacing toolbar factories or submenus.
     */
    mediaToolbarIcons?: MediaToolbarIconsResolver;
    /**
     * Replace-URL popover slot. Return the popover content for the node-anchored
     * dialog, or `null` to opt out so the host renders its own surface (mobile
     * sheet). Omit to use the built-in URL editor.
     */
    replaceUrlPopover?: ReplaceUrlPopoverFactory;
    /** Return true for host-uploaded assets so "View original" is hidden (image/video/audio). */
    isUploadedMedia?: (ctx: MediaActionContext) => boolean;
}
declare const HyperMultimediaKit: Extension<HyperMultimediaKitOptions, any>;

declare const isImageUrl: (url: string) => boolean;

declare const isValidLoomUrl: (url: string) => boolean;

declare function isValidSoundCloudUrl(url: string): boolean;

/** True for any URL or `spotify:` URI that resolves to an embeddable entity. */
declare const isValidSpotifyUrl: (url: string) => boolean;

declare const isValidVimeoUrl: (url: string) => boolean;

declare function isValidXUrl(url: string): boolean;

declare const isValidYoutubeUrl: (url: string) => boolean;

/** Where a brick snaps relative to another by id; omit both to append to the end. */
interface MediaActionAnchor {
    before?: string;
    after?: string;
}
/** Immutable lego-style editor for the resolved action list — every method returns a new builder. */
interface MediaActionsBuilder {
    /** Insert (or move, if the id already exists) a brick at the anchor. */
    add(action: MediaAction, at?: MediaActionAnchor): MediaActionsBuilder;
    remove(...ids: string[]): MediaActionsBuilder;
    /** Reposition an existing brick; no-op if the id is absent. */
    move(id: string, at: MediaActionAnchor): MediaActionsBuilder;
    /** Swap a brick's definition in place; no-op if the id is absent. */
    replace(id: string, action: MediaAction): MediaActionsBuilder;
    setPlacement(id: string, placement: MediaActionPlacement): MediaActionsBuilder;
    toInline(id: string): MediaActionsBuilder;
    toOverflow(id: string): MediaActionsBuilder;
    /** Order listed ids first (in the given sequence); unlisted bricks keep their relative order after. */
    order(ids: string[]): MediaActionsBuilder;
    has(id: string): boolean;
    result(): MediaActionList;
}
/** Start a lego-style edit over a resolved action list (typically the `mediaActions` `defaults`). */
declare function composeMediaActions(actions: MediaActionList): MediaActionsBuilder;
/** Declarative row layout by id; unlisted known actions keep their placement and append after. */
interface MediaToolbarLayout {
    inline?: string[];
    overflow?: string[];
}
/** Sugar: a `mediaActions` resolver that arranges the inline and overflow rows by id. */
declare function layoutMediaActions(layout: MediaToolbarLayout | ((ctx: {
    nodeType: string;
}) => MediaToolbarLayout)): MediaActionsResolver;

/** Default desktop toolbar: resolve actions for the node, render the in-place bar. */
declare const createMediaToolbar: MediaToolbarFactory;

/** Downloadable local-asset kinds (image/audio/video); see `media-target.mediaKind`. */
declare function isDownloadable(nodeType: string): boolean;
/** View Original: embeds always; uploaded image/video/audio hidden. */
declare function canViewOriginal(ctx: MediaActionContext): boolean;
declare function viewOriginalMedia(ctx: MediaActionContext): void;
declare function removeMediaNode(ctx: MediaActionContext): void;
declare function copyMediaNode(ctx: MediaActionContext): Promise<void>;
/** Same-origin / blob URLs download; cross-origin without CORS falls back to opening a tab. */
declare function downloadMedia(ctx: MediaActionContext): Promise<void>;

type OpenMediaPopoverOptions = {
    kind: string;
    content: HTMLElement;
    /** Click target — ignored for light-dismiss so toggle works. */
    trigger: HTMLElement;
    /** Position surface; defaults to `trigger`. Overflow menus pass the toolbar bar. */
    positionReference?: HTMLElement;
    variant?: 'menu' | 'dialog';
    role?: string;
    ariaLabel?: string;
    /** When false, skip toggle-close if the same kind is already open (dialogs). Default true for menu. */
    toggle?: boolean;
};
/**
 * Media toolbar popover adapter — owns toggle, menu offset/shift, and dismiss-ignore.
 * Callers pass content + kind + anchors only.
 */
declare function openMediaPopover(options: OpenMediaPopoverOptions): void;
type OpenToolbarPopoverOptions = {
    /** Position against this surface; defaults to `trigger`. Overflow menus pass the toolbar bar. */
    positionReference?: HTMLElement;
};
/** Toggle an anchored menu popover on the shared controller; one open at a time. */
declare function openToolbarPopover(trigger: HTMLElement, body: HTMLElement, kind: string, options?: OpenToolbarPopoverOptions): void;
/** Close the popover opened by `openToolbarPopover` / `openMediaPopover`, if any. */
declare function closeToolbarPopover(): void;

/** Mount the toolbar inside the media wrapper (absolute top-right). `null` ⇒ host surface. */
declare function openMediaToolbar(options: MediaToolbarOptions, factory?: MediaToolbarFactory): HTMLElement | null;
/** Remove the mounted toolbar, any open menu popover, and a lingering tooltip. */
declare function closeMediaToolbar(wrapper?: HTMLElement | null): void;

/** Base bricks + per-node recipe (array order is final) → host `mediaActions` override. */
declare function resolveMediaActions(editor: Editor, nodeType: string): MediaActionList;

/** Hide the shared tooltip bubble and cancel any pending show. */
declare function hideTooltip(): void;
/** Show `label` above `target` after a short hover/focus delay. Returns a detach function for surfaces that re-render in place. */
declare function attachTooltip(target: HTMLElement, label: string): () => void;

/** Every media node `.name`, the source of truth for which node a URL inserts. */
type MediaNodeType = 'image' | 'video' | 'audio' | 'youtube' | 'vimeo' | 'soundcloud' | 'spotify' | 'loom' | 'x';
/**
 * Resolve a URL to the media node that should render it, or null when none does.
 * Specific providers and image win before the generic video/audio extension
 * matchers, so a `youtube.com/...webm` URL maps to youtube, not video.
 */
declare const detectMediaType: (url: string) => MediaNodeType | null;

interface FitBounds {
    maxWidth: number;
    maxHeight?: number;
}
declare function fitDimensionsToBounds(width: number, height: number, bounds: FitBounds): {
    width: number;
    height: number;
};
/** ProseMirror content width — caps insert + resize to the editable column. */
declare function getEditorContentWidth(editor: Editor): number;
/** Scale layout down when width exceeds the editable column (insert + resize). */
declare function fitLayoutToEditorColumn(editor: Editor, width: number, height: number): {
    width: number;
    height: number;
};

/**
 * True if `url` is one this kit auto-converts to a media node on paste.
 * A host running a link extension alongside it should veto these so media
 * URLs become nodes, not links: `Hyperlink.configure({ shouldAutoLink: (url)
 * => !isMediaUrl(url) })`. Resolves the paste precedence between the two.
 */
declare const isMediaUrl: (url: string) => boolean;

declare const applyNodeAttributes: (editor: Editor, nodePos: number, attributes: Record<string, string | number | null>) => void;

/** DOM → doc position with a node-type guard; also re-resolves stale drag-end positions. */
declare function resolveMediaNodePos(view: Editor['view'], target: HTMLElement, nodeType: string): number | null;

declare const isVideoUrl: (url: string) => boolean;
declare const isAudioUrl: (url: string) => boolean;

export { type AddXOptions, HyperMultimediaKit, type HyperMultimediaKitOptions, MEDIA_MARGIN_OPTIONS, MEDIA_PLACEMENT_OPTIONS, type MediaAction, type MediaActionAnchor, type MediaActionContext, type MediaActionList, type MediaActionPlacement, type MediaActionsBuilder, type MediaActionsResolver, type MediaLoadingBindLoadOptions, type MediaLoadingController, type MediaLoadingKind, type MediaLoadingShellContext, type MediaLoadingShellFactory, type MediaLoadingShellOption, type MediaLoadingShellWrapOptions, type MediaNodeType, type MediaPlacementId, type MediaPublicCommands, type MediaToolbarFactory, type MediaToolbarIconContext, type MediaToolbarIconKey, type MediaToolbarIconsResolver, type MediaToolbarLayout, type MediaToolbarOptions, type ReplaceUrlPopoverFactory, type ReplaceUrlPopoverOptions, SPOTIFY_ENTITY_TYPES, type SetAudioOptions, type SetImageOptions, type SetLoomOptions, type SetSoundCloudOptions, type SetSpotifyOptions, type SetVideoOptions, type SetVimeoOptions, type SetYoutubeVideoOptions, type SpotifyEntityType, type SpotifyTheme, type UpdateImageDimensionsParams, type XEmbedSizeId, type XEmbedTheme, X_EMBED_DEFAULT_MAXWIDTH, X_EMBED_SIZE_OPTIONS, X_EMBED_THEME_OPTIONS, applyNodeAttributes, attachTooltip, buildXOEmbedParams, canViewOriginal, closeMediaToolbar, closeToolbarPopover, composeMediaActions, copyMediaNode, createDefaultMediaLoadingShell, createMediaToolbar, createReplaceUrlPopover, detectMediaType, downloadMedia, fitDimensionsToBounds, fitLayoutToEditorColumn, getCurrentMediaPlacement, getEditorContentWidth, getMediaPlacementAttrs, hideTooltip, isAudioUrl, isDownloadable, isImageUrl, isMediaUrl, isValidLoomUrl, isValidSoundCloudUrl, isValidSpotifyUrl, isValidVimeoUrl, isValidXUrl, isValidYoutubeUrl, isVideoUrl, layoutMediaActions, openMediaPopover, openMediaToolbar, openReplaceUrlPopover, openToolbarPopover, parseSpotifyEntity, parseYoutubeVideoId, removeMediaNode, resolveMediaActions, resolveMediaNodePos, resolveXEmbedSizeId, viewOriginalMedia, wrapMediaWithLoadingShell };