vue - API Reference | PPTX Editor

Package root

Functions (48)

`definePopup`functionSource ↗

Register an ordinary component in the popups map while keeping its props and state, as React's definePopup and DOCX Editor's Vue definePopup: the component's required and narrowed props stay checked against the entry; Vue's own attributes do not constrain it.

declare function definePopup<C extends Component | FunctionalComponent<never>>(component: C, options?: DefinePopupOptions): (props: C extends new (...args: never[]) => {
    $props: infer P;
} ? Omit<P, {
    [K in keyof P]-?: K extends keyof (VNodeProps & AllowedComponentProps & ComponentCustomProps) ? {} extends Pick<P, K> ? (VNodeProps & AllowedComponentProps & ComponentCustomProps)[K] extends P[K] ? K : never : never : never;
}[keyof P]> : C extends (props: infer P, ...args: never[]) => unknown ? P : never) => VNodeChild;

`rejectionMessage`functionSource ↗

The message for a refusal: its reason, with the detail where the reason names one.

declare function rejectionMessage(t: Translate, rejection: EditorRejection): string;

`requestFindBar`functionSource ↗

Open the find bar of editor: to find, or with the replace row when replace.

declare function requestFindBar(editor: PptxEditorInstance | null, replace?: boolean): void;

`requestSectionRename`functionSource ↗

Ask the slide rail or the slide sorter of editor to start renaming section sectionId in place, as Home Section Rename Section does: what the section.rename slot runs. Use it when you build your own section chrome. When neither is mounted, nothing opens and a development warning says so. The twin of React's requestSectionRename.

declare function requestSectionRename(editor: PptxEditorInstance | null, sectionId: string): void;

`useBackgroundDialog`functionSource ↗

Read the draft of the enclosing Background dialog, for a host's own field inside it. It does not open the dialog: useEditorDialog('background').open() does.

declare function useBackgroundDialog(): UseBackgroundDialogReturn;

`useBulletFormat`functionSource ↗

The bullet format of the selected paragraphs, and the command to change it, as React's useBulletFormat.

declare function useBulletFormat(): UseBulletFormatReturn;

`useBulletsAndNumberingDialog`functionSource ↗

Read the draft of the enclosing Bullets and Numbering dialog, for a host's own field inside it. It does not open the dialog: useEditorDialog('bulletsAndNumbering').open() does.

declare function useBulletsAndNumberingDialog(): UseBulletsAndNumberingDialogReturn;

`useChromeTranslate`functionSource ↗

The chrome's translation function, as React's useChromeTranslate: the t of the nearest compound that takes one, else the root's locale. overrides wins for the keys it holds.

declare function useChromeTranslate(overrides?: ReadonlyMap<string, string>): UseChromeTranslateReturn;

`useColumnsDialog`functionSource ↗

Read the draft of the enclosing Columns dialog, for a host's own field inside it. It does not open the dialog: useEditorDialog('columns').open() does.

declare function useColumnsDialog(): UseColumnsDialogReturn;

`useContextMenuRequest`functionSource ↗

The open canvas context menu, for a host's own rows: what it opened on, where, and how to close it. Null outside an open menu. Each request mounts the menu anew, so the value is fixed for the menu's life.

declare function useContextMenuRequest(): UseContextMenuRequestReturn;

`useContextMenuTarget`functionSource ↗

The element the open context menu opened on (the slide canvas), or null while no menu is open. The same composable as DOCX Editor's.

declare function useContextMenuTarget(): UseContextMenuTargetReturn;

`useDocumentSearch`functionSource ↗

The editor's find session with no UI, for your own find bar, as React's useDocumentSearch. Every composable on one editor shares the session.

declare function useDocumentSearch(): UseDocumentSearchReturn;

`useEditorCaret`functionSource ↗

The caret, as React's useEditorCaret: the text box, paragraph, and offset, or null when no text is being edited. The ref changes only when the caret moves.

declare function useEditorCaret(): UseEditorCaretReturn;

`useEditorColorMode`functionSource ↗

The theme the enclosing PptxEditorRoot resolved from its colorMode, as React's useEditorColorMode and DOCX Editor's. Outside a root, or without colorMode, it is 'light'. Call it in setup.

declare function useEditorColorMode(): UseEditorColorModeReturn;

`useEditorCommand`functionSource ↗

State and execution for one ChromeSlotId, as React's useEditorCommand. The slot may be a ref or a getter, as in DOCX Editor's Vue adapter: the state follows it.

declare function useEditorCommand(slot: MaybeRefOrGetter<ChromeSlotId>): UseEditorCommandReturn;

`useEditorDialog`functionSource ↗

Open, close, and read one of the editor's dialogs, as React's useEditorDialog. Outside PptxEditorRoot it reports the dialog as unavailable.

declare function useEditorDialog(key: PptxEditorDialogKey): UseEditorDialogReturn;

`useEditorEvent`functionSource ↗

Subscribe to an editor event ('change', 'selectionChange', 'rejection', 'openFailure') for the lifetime of the component, as React's useEditorEvent and DOCX Editor's. It does nothing until PptxEditorRoot creates the editor, and subscribes again when the instance changes.

declare function useEditorEvent<E extends keyof PptxEditorEvents>(event: E, handler: PptxEditorEvents[E]): UseEditorEventReturn;

`useEditorHostDocument`functionSource ↗

The document that the editor's slide is mounted in, the twin of React's useEditorHostDocument: an iframe's when the host mounted the editor there, else the page's own. Null during server rendering.

declare function useEditorHostDocument(): UseEditorHostDocumentReturn;

`useEditorSnapshot`functionSource ↗

A counter that changes each time editor publishes a change, as React's useEditorSnapshot and DOCX Editor's. Read it in a render function or a computed to follow the editor. Prefer useEditorState with a selector.

declare function useEditorSnapshot(editor: MaybeRefOrGetter<PptxEditorInstance | null>): UseEditorSnapshotReturn;

`useEditorState`functionSource ↗

Subscribe to a slice of editor state. The ref updates only when isEqual says the slice changed (default Object.is), as React's useEditorState.

declare function useEditorState<T>(selector: (snapshot: EditorSnapshot) => T, isEqual?: (a: T, b: T) => boolean): UseEditorStateReturn<T>;

`useEditorValueCommand`functionSource ↗

State and execution for one typed value slot, as React's useEditorValueCommand: execute takes the slot's ToolbarValueMap type and returns the engine's result.

declare function useEditorValueCommand<K extends keyof ToolbarValueMap>(slot: MaybeRefOrGetter<K>): UseEditorValueCommandReturn<ToolbarValueMap[K], ToolbarShownValue<K>>;

`useEquationDialog`functionSource ↗

Read the draft of the enclosing Equation dialog, for a host's own field inside it. It does not open the dialog: useEditorDialog('equation').open() does.

declare function useEquationDialog(): UseEquationDialogReturn;

`useFontDialog`functionSource ↗

Read the draft of the enclosing Font dialog, for a host's own field inside it. It does not open the dialog: useEditorDialog('font').open() does.

declare function useFontDialog(): UseFontDialogReturn;

`useFontFamily`functionSource ↗

The font family picker's behavior, with no UI, as React's useFontFamily and DOCX Editor's Vue composable of the same name.

declare function useFontFamily(): UseFontFamilyReturn;

`useFontFormat`functionSource ↗

The font of the selected text (or of every run of the selected shapes), and the command to change it, as React's useFontFormat.

declare function useFontFormat(): UseFontFormatReturn;

`useFonts`functionSource ↗

Merge font origins into one stable value for the fonts prop of PptxEditor or PptxEditorRoot, as React's useFonts: useFonts(packagedFonts()), or useFonts(brandFragment, packagedFonts()) for brand faces first. Origins compose first-wins in argument order and resolve one after another. The value never changes identity, so the fonts are not replaced on a re-render; ref and getter arguments are read again when a deck opens or a family is requested.

declare function useFonts(source: MaybeRefOrGetter<FontsInput>, ...fragments: readonly MaybeRefOrGetter<FontConfigurationFragment | undefined>[]): UseFontsReturn;

`useFonts`functionSource ↗

The uniform form: every position takes the same FontOrigin, so composing two resolvers is one extra argument. A resolver after the first position must carry the defineFontResolver mark.

declare function useFonts(...origins: readonly MaybeRefOrGetter<FontOrigin>[]): UseFontsReturn;

`useHistoryGroup`functionSource ↗

One undo step for one gesture on your own control, as React's useHistoryGroup. Bind the control with :ref="group.ref", and pass group.options() to each command of the gesture.

declare function useHistoryGroup(input: HistoryGroupBindingOptions): UseHistoryGroupReturn;

`useHyperlinkPopup`functionSource ↗

The link popup's behavior, for your own link UI, the twin of React's useHyperlinkPopup. Inside PptxEditorRoot it is the shared state that the packaged popup shows; with popups.hyperlink: false, the link controls open your panel while it is mounted. Outside a root it is a standalone instance.

declare function useHyperlinkPopup(): UseHyperlinkPopupReturn;

`useHyperlinkPopupInstance`functionSource ↗

A link popup of its own, the twin of React's useHyperlinkPopupInstance. While active, it opens for the link requests of the editor.

declare function useHyperlinkPopupInstance(active?: boolean): UseHyperlinkPopupInstanceReturn;

`useImageAltTextDialog`functionSource ↗

Read the draft of the enclosing Alt Text dialog, for a host's own field inside it. It does not open the dialog: useEditorDialog('imageAltText').open() does.

declare function useImageAltTextDialog(): UseImageAltTextDialogReturn;

`useImagePropertiesDialog`functionSource ↗

Read the draft of the enclosing Format Picture dialog, for a host's own field inside it. It does not open the dialog: useEditorDialog('imageProperties').open() does.

declare function useImagePropertiesDialog(): UseImagePropertiesDialogReturn;

`useNotesPane`functionSource ↗

The open state of the speaker notes that the notes pane shows, as React's useNotesPane and DOCX Editor's useNavigationPane. Use it to build a notes toggle of your own. Outside PptxEditorRoot it warns and does nothing.

declare function useNotesPane(): UseNotesPaneReturn;

`useOpenFailure`functionSource ↗

Reads the file the editor refused to open, for a host that shows it in its own UI, such as a toast. Pair it with :open-failure="false" on PptxEditor, so the packaged notice does not show as well. Call it inside a PptxEditorRoot.

declare function useOpenFailure(options?: UseOpenFailureOptions): UseOpenFailureReturn;

`usePageSetupDialog`functionSource ↗

Read the draft of the enclosing Page setup dialog, for a host's own field inside it. It does not open the dialog: useEditorDialog('pageSetup').open() does.

declare function usePageSetupDialog(): UsePageSetupDialogReturn;

`useParagraphDialog`functionSource ↗

Read the draft of the enclosing Paragraph dialog, for a host's own field inside it. It does not open the dialog: useEditorDialog('paragraph').open() does.

declare function useParagraphDialog(): UseParagraphDialogReturn;

`useParagraphFormat`functionSource ↗

The selection's paragraph formatting, and the command to change it, as React's useParagraphFormat and DOCX Editor's Vue composable of the same name.

declare function useParagraphFormat(): UseParagraphFormatReturn;

`usePptxEditor`functionSource ↗

The editor instance, or null before it mounts. Outside PptxEditorRoot it is always null, and a development warning says so, as for the other parts.

declare function usePptxEditor(): UsePptxEditorReturn;

`usePptxSource`functionSource ↗

Load a presentation, and optionally its fonts, for PptxEditor, the twin of React's usePptxSource and of DOCX Editor's useDocxSource. Eager fonts hold the deck back until they settle, for at most 2 seconds; an on-demand resolver does not. A font failure never fails the deck, and a URL that sends no bytes for 10 seconds fails with an error.

declare function usePptxSource(source: MaybeRefOrGetter<PptxSource | null | undefined>, options?: MaybeRefOrGetter<UsePptxSourceOptions>): UsePptxSourceReturn;

`useReviewAuthors`functionSource ↗

The review authors of the open deck, in slot order (getReviewAuthors): every comment author by first appearance, then the author of new comments, each with the color the comment markers, the text bands, and the comments pane draw them in, as React's useReviewAuthors. The ref changes only when a slot changes.

declare function useReviewAuthors(): UseReviewAuthorsReturn;

`useScopeClassName`functionSource ↗

The scope classes a part you build yourself adds to its own root element, so the editor's --doc-* tokens and chrome styles apply to it, as React's useScopeClassName. Inside PptxEditorViewport it is ''. Outside it, it is 'pptx-editor ', or 'pptx-editor dark ' when the root's colorMode resolved dark. It is a ref, so it follows a 'system' color mode. The value ends with a space, so it concatenates cleanly.

declare function useScopeClassName(): UseScopeClassNameReturn;

`useSlideLayouts`functionSource ↗

The deck's slide layouts (EditorSnapshot.layouts), in the order the galleries list them, as React's useSlideLayouts. For a host's own layout picker.

declare function useSlideLayouts(): UseSlideLayoutsReturn;

`useSlideshow`functionSource ↗

The slide show of the editor in PptxEditorRoot, as React's useSlideshow.

declare function useSlideshow(): UseSlideshowReturn;

`useToolbarContext`functionSource ↗

The nearest compound's published value, as React's useToolbarContext.

declare function useToolbarContext(): UseToolbarContextReturn;

`useToolbarLabel`functionSource ↗

The label for a key: the nearest compound's t, else the locale catalog.

declare function useToolbarLabel(): UseToolbarLabelReturn;

`useToolbarLabelFor`functionSource ↗

The label for a key: the host's translation, else the locale catalog.

declare function useToolbarLabelFor(t: ChromeTranslate | undefined): UseToolbarLabelForReturn;

`useTranslation`functionSource ↗

The translator, with shortcut text for this platform.

declare function useTranslation(): UseTranslationReturn;

`useZoom`functionSource ↗

Read and set the slide zoom, as React's useZoom and DOCX Editor's. Outside PptxEditorRoot, and before the editor mounts, it reports 100 % and every action does nothing.

declare function useZoom(): UseZoomReturn;

Interfaces (38)

`BackgroundDialogFields`interfaceSource ↗

The draft of the Background dialog. background is the fill OK applies: a fill, null for the layout's background, or undefined to keep the slide's own fill.

interface BackgroundDialogFields

Member	Type	Summary
allSlides	`boolean`	Apply the fill to every slide.
background	`SlideBackground \| null \| undefined`	The fill OK applies: a fill, `null` for the layout's background, `undefined` to keep the slide's own.

`ContextMenuPoint`interfaceSource ↗

A point in client (viewport) pixels.

interface ContextMenuPoint

Member	Type	Summary
x	`number`	The horizontal position in CSS pixels from the left of the window.
y	`number`	The vertical position in CSS pixels from the top of the window.

`ContextMenuRequest`interfaceSource ↗

What a canvas context menu opened on, and where.

interface ContextMenuRequest

Member	Type	Summary
at	`ContextMenuPoint`	Where the menu opens, in client pixels.
close	`() => void`	Close the menu.
keyboard	`boolean`	Opened from the keyboard: focus goes to the first row.
kind	`CanvasMenuKind`	Shapes, pictures only (`picture`, the picture menu), text being edited, or empty slide area. A selection of pictures only reports `picture`, not `shapes`.
owner	`HTMLElement`	The canvas element the menu opened on.

`DefinePopupOptions`interfaceSource ↗

Options of definePopup, the twin of React's DefinePopupOptions.

interface DefinePopupOptions

Member	Type	Summary
reading?	`boolean`	For `popups.hyperlink`: the renderer shows reading mode too, so a click into linked text opens it with `mode: 'reading'`. Without it a renderer opens for the URL field alone.

`DialogCustomizationProps`interfaceSource ↗

Layout customization for a packaged dialog, the twin of React's DialogCustomizationProps and DOCX Editor's Vue one. Vue passes children through the default slot, not a prop.

interface DialogCustomizationProps

Member	Type	Summary
className?	`string`	A class name added to the dialog surface (`class` works too).
preset?	`boolean`	`true` (default): the default arrangement with host parts in place. `false`: only the slot.
style?	`CSSProperties`	Styles added to the dialog surface.

`DialogPartProps`interfaceSource ↗

Presentation props of a dialog part, the twin of React's DialogPartProps. Other attributes (id, aria-*, data-*) reach the rendered element; the part's own wiring wins every collision.

interface DialogPartProps

Member	Type	Summary
"aria-label"?	`string`	The accessible name of the part's element.
(member-1)		`data-*` attributes, passed to the part's element.
asChild?	`boolean`	Apply the part's wiring to the single child element.
className?	`string`	A class name added to the part (`class` works too).
hidden?	`boolean`	Remove the part from the arrangement.
id?	`string`	The id of the part's element.
style?	`CSSProperties`	Styles added to the part.
title?	`string`	The tooltip of the part's element.

`EquationDialogFields`interfaceSource ↗

The draft of the Equation dialog.

interface EquationDialogFields

Member	Type	Summary
linear	`string`	The linear form of the equation, such as `x=(-b\pm\sqrt(b^2-4ac))/(2a)`.

`FindPopupProps`interfaceSource ↗

What a replacement find bar receives, as React's FindPopupProps.

interface FindPopupProps

Member	Type	Summary
onClose	`() => void`	Close the bar. Run `editor.find` and `editor.replace` for the search itself.
replace	`boolean`	Opened to replace (Ctrl/Cmd+H), not only to find.

`ImageAltTextDialogFields`interfaceSource ↗

The draft of the Alt Text dialog.

interface ImageAltTextDialogFields

Member	Type	Summary
decorative	`boolean`	Mark as decorative: a screen reader skips the element, and the description is dropped.
description	`string`	The description a screen reader reads (`p:cNvPr/@descr`).
title	`string`	The title (`p:cNvPr/@title`).

`ImagePropertiesDialogFields`interfaceSource ↗

The draft of the Format Picture dialog, in inches, degrees, and percent.

interface ImagePropertiesDialogFields

Member	Type	Summary
cropBottom	`number`	Crop of the bottom edge, in percent of the image.
cropLeft	`number`	Crop of the left edge, in percent of the image; a negative value adds space.
cropRight	`number`	Crop of the right edge, in percent of the image.
cropTop	`number`	Crop of the top edge, in percent of the image.
height	`number`	Height in inches, on the slide (`SelectedImageState.heightEmu`).
lockAspect	`boolean`	Lock aspect ratio: a width change scales the height, and the other way round.
rotation	`number`	Rotation in degrees, clockwise.
width	`number`	Width in inches, on the slide (`SelectedImageState.widthEmu`).

`OpenFailureContext`interfaceSource ↗

What the actions slot receives, the twin of React's OpenFailureContext.

interface OpenFailureContext

Member	Type	Summary
dismiss		Close the notice. It emits `dismiss`, as Close does.
failure	`DocumentOpenFailure`	The refused open: its stable `code` and its `reason`.
message	`string`	The packaged, translated message for the failure.

`PageSetupDialogFields`interfaceSource ↗

The draft of the Page setup dialog.

interface PageSetupDialogFields

Member	Type	Summary
slideSize	`SlideSizeFields`	The slide size: a preset, the width and height in inches, and whether content scales.
theme	`'light' \| 'dark'`	The chrome theme the appearance choice shows.

`PptxEditorDialogSessionProps`interfaceSource ↗

The props a registry dialog receives: it shows, and how to close it.

interface PptxEditorDialogSessionProps

Member	Type	Summary
onClose	`() => void`	Close the dialog: the registry stops rendering it and focus returns to the opener.
open	`boolean`	Always true while the registry renders the dialog.

`PptxEditorPopups`interfaceSource ↗

Render overrides for the dialogs the editor mounts. A render callback replaces the packaged dialog; false disables one.

interface PptxEditorPopups

Member	Type	Summary
background?	`PptxEditorPopup<BackgroundDialogProps>`	Format background: slide background fill.
bulletsAndNumbering?	`PptxEditorPopup<BulletsAndNumberingDialogProps>`	Format Bullets and Numbering: bullet or number style, size, color, and start number.
columns?	`PptxEditorPopup<ColumnsDialogProps>`	Home Columns More Columns: the number of text columns and the spacing between them.
contextMenu?	`PptxEditorPopup<PptxEditorContextMenuProps>`	The slide canvas's context menu. A callback usually renders `PptxEditorContextMenu` with host rows; `false` shows no menu. A `PptxEditorContextMenu` placed in the root or the viewport gives the same entry, and this entry wins over it.
equation?	`PptxEditorPopup<EquationDialogProps>`	Insert Equation: a gallery and the linear form of an equation, which inserts an equation or edits the selected one. `false` turns it off; `insertEquation` and `setEquation` keep working from the API.
find?	`PptxEditorPopup<FindPopupProps>`	The find and replace bar (Ctrl/Cmd+F, Ctrl/Cmd+H), rendered where `PptxEditorFindBar` stands. `false` turns it off; `editor.find` keeps working from the API.
font?	`PptxEditorPopup<FontDialogProps>`	Format Font: font, effects, offset, character spacing, and kerning.
hyperlink?	`PptxEditorPopup<HyperlinkPopupProps>`	The link popup (Ctrl/Cmd+K, the link control, Insert Link). `PptxEditorRoot` hosts it, so it opens with no toolbar on the page. `false` turns links off in the chrome; `setLink` keeps working from the API.
imageAltText?	`PptxEditorPopup<ImageAltTextDialogProps>`	The Alt Text dialog of the selected element, as DOCX Editor's `imageAltText`.
imageProperties?	`PptxEditorPopup<ImagePropertiesDialogProps>`	The Format Picture dialog of the selected picture, as DOCX Editor's `imageProperties`.
pageSetup?	`PptxEditorPopup<PageSetupDialogProps>`	File Page setup: slide size, appearance, and fonts.
paragraph?	`PptxEditorPopup<ParagraphDialogProps>`	Format Paragraph: alignment, indents, spacing before and after, and line spacing.
railContextMenu?	`PptxEditorPopup<RailContextMenuProps>`	The context menu of a slide in the slide rail and of a tile in the slide sorter. A callback renders the host's menu, or `RailContextMenu` with its own options; `false` shows no menu.
sectionContextMenu?	`PptxEditorPopup<SectionContextMenuProps>`	The menu of a section header in the slide rail and in the slide sorter. A callback renders the host's menu, or `SectionContextMenu` with its own options; `false` shows no menu.

`PptxEditorRef`interfaceSource ↗

The imperative handle of PptxEditor and PptxEditorRoot, the twin of React's PptxEditorRef and of DOCX Editor's DocxEditorRef: a template ref on either component reads these members (expose). Every member forwards to the editor instance and is safe to call before the editor mounts: load and exec refuse with disabled.noEditor, save and getEditor return null, focus does nothing, and snapshot returns an empty snapshot. Everything else is on the instance that getEditor returns.

interface PptxEditorRef

Member	Type	Summary
exec		Run a command, as `editor.exec`.
focus		Give the keyboard back to the slide: the text caret, else the slide surface.
getEditor		The editor instance, or `null` before it mounts.
load		Open `.pptx` bytes. Resolves when the presentation is open, or with the refusal. A long deck resolves when `options.startSlide` (or the first slide) is ready.
save		The presentation as `.pptx` bytes. The bytes own an `ArrayBuffer`, so `new Blob([bytes])` takes them as they are. `null` when no presentation is open, and when a slide of it is damaged: `snapshot().readOnlyReason` is then `'damaged-slide'` (after edits), or `snapshot().openFailure` reports the refused file.
snapshot		The current editor state, as `editor.snapshot()`.

`RailMenuState`interfaceSource ↗

An open rail menu: where, on which slide, and how it opened.

interface RailMenuState

Member	Type	Summary
at	`ContextMenuPoint`	Where the menu opens: the pointer, or the slide for a keyboard open.
index	`number`	The slide the menu opened on, from 0.
keyboard	`boolean`	Opened from the keyboard: focus goes to the first row.
owner	`HTMLElement \| null`	The element the menu opened on; its editor scope carries the theme tokens.

`SectionMenuState`interfaceSource ↗

An open section menu: where it opens, how it opened, and the element it belongs to.

interface SectionMenuState

Member	Type	Summary
at	`ContextMenuPoint`	The point where the menu opens, in viewport pixels.
keyboard	`boolean`	Whether a key opened the menu (Shift+F10 or the Menu key). The menu then puts focus on its first row; after a right-click, on the menu itself.
owner	`HTMLElement \| null`	The element the menu belongs to: the section header. Focus goes back to it on close.

`UseBackgroundDialogReturn`interfaceSource ↗

The Background draft and its actions.

interface UseBackgroundDialogReturn extends UseDialogReturn<BackgroundDialogFields>

Member	Type	Summary
reset		Pick the layout's background in the draft.

`UseBulletFormatReturn`interfaceSource ↗

What useBulletFormat returns.

interface UseBulletFormatReturn

Member	Type	Summary
apply	`(format: BulletFormat \| null) => boolean`	Write a bullet format (null turns the list off) as ONE undo step. An omitted field keeps each paragraph's value; with no `kind`, the size and color change and each paragraph keeps its own bullet or number. Returns whether the engine accepted it.
format	`UseEditorStateReturn<BulletFormatRead \| null \| undefined>`	The bullet format of the selected paragraphs: null when they have no list, undefined when they differ or nothing with text is selected.
isEnabled	`ComputedRef<boolean>`	Whether the engine can write a bullet format now (text or a shape with text selected, editable).

`UseDialogReturn`interfaceSource ↗

A dialog's draft and actions, as its parts and a host's own fields read them.

interface UseDialogReturn<Fields extends object>

Member	Type	Summary
apply		Validate and commit the draft. The dialog closes when the document took it.
cancel		Discard the draft and close.
errors	`Readonly<Ref<Readonly<Partial<Record<Extract<keyof Fields, string> \| 'form', string>>>>>`	Translated messages per field, and `form` for the whole draft.
isEnabled	`Readonly<Ref<boolean>>`	False when the dialog cannot apply now (no document, viewing mode).
setValue		Change one field of the draft.
values	`Readonly<Ref<Fields>>`	The draft values.

`UseDocumentSearchReturn`interfaceSource ↗

What [useDocumentSearch](useDocumentSearch) returns: the session's state as refs, and its actions.

interface UseDocumentSearchReturn

Member	Type	Summary
activeIndex	`ComputedRef<number>`
activeMatch	`ComputedRef<FindMatch \| null>`
clear	`() => void`
find	`(query: string, options?: DocumentSearchFindOptions) => readonly FindMatch[]`
goTo	`(index: number) => boolean`
isPending	`ComputedRef<boolean>`
matchCase	`ComputedRef<boolean>`
matches	`ComputedRef<readonly FindMatch[]>`
next	`() => boolean`
previous	`() => boolean`
query	`ComputedRef<string>`
setMatchCase	`(value: boolean) => void`
setQuery	`(query: string) => void`
setWholeWord	`(value: boolean) => void`
truncated	`ComputedRef<boolean>`
wholeWord	`ComputedRef<boolean>`

`UseEditorColorModeReturn`interfaceSource ↗

What useEditorColorMode returns.

interface UseEditorColorModeReturn

Member	Type	Summary
colorMode	`ComputedRef<ResolvedColorMode>`	The resolved theme: `'dark'` or `'light'`. Updates when `colorMode` or the OS setting changes.

`UseEditorCommandReturn`interfaceSource ↗

What useEditorCommand returns: one source of enabled state, and the runner.

interface UseEditorCommandReturn

Member	Type	Summary
disabledReason	`ComputedRef<string \| null>`	A translation key, or the engine's own text, when the control is disabled.
execute	`(value?: unknown) => boolean`	Run the slot's command, with a value for value controls: the picked option's value, a number of points for `font.size`, or `{ step: 1 }` / `{ step: -1 }` for its Increase and Decrease Font Size buttons (`commandForSlotValue`). Returns true when the engine ran it and false on a refusal, as in DOCX Editor.
isActive	`ComputedRef<boolean>`	Whether a toggle control shows as pressed.
isEnabled	`ComputedRef<boolean>`	Whether the command can run now.
value	`ComputedRef<string \| number \| undefined>`	The value a value control shows (a font size, a family), when it has one.

`UseEditorDialogReturn`interfaceSource ↗

What useEditorDialog returns, the twin of React's UseEditorDialogReturn.

interface UseEditorDialogReturn

Member	Type	Summary
close		Hide the dialog.
isAvailable	`ComputedRef<boolean>`	False when the dialog cannot show: hide or disable the control that opens it.
isOpen	`ComputedRef<boolean>`	Whether the dialog shows now.
open		Show the dialog. Focus returns to `returnFocusTo`, or the element with focus now.

`UseEditorValueCommandReturn`interfaceSource ↗

What useEditorValueCommand returns, as React's UseEditorValueCommandReturn.

interface UseEditorValueCommandReturn<V, S = V>

Member	Type	Summary
disabledReason	`ComputedRef<string \| null>`	Why the command cannot run: a catalog key, or the engine's own text.
execute	`(value: V, options?: EditorExecOptions) => CommandResult`	Run the slot's command with a value of its `ToolbarValueMap` type. The result says why the engine refused it (`disabled.invalidValue`, `disabled.noEffectChange`). Pass `{ historyGroup }` to make the values of one gesture (a slider drag) one undo step.
isEnabled	`ComputedRef<boolean>`	Whether the command can run now.
options	`ComputedRef<readonly V[]>`	The slot's fixed choices, from the registry (the Rotate, Align, line width, or Shape Effects rows); none for a slot with a free value (`font.size`, `shape.fill`, `shape.styles`). Without the `@pptx-editor.dev/pro/drawing` module, they leave out the effects it paints (`chromeOfferedControl`), so `value` can be an effect from the file that is not in the list. They keep the rows that remove an effect the selection has (`reflection.none`).
value	`ComputedRef<S \| null>`	The value the slot shows (`ToolbarShownValue`), or null when it is mixed or unavailable.

`UseFontFamilyReturn`interfaceSource ↗

What useFontFamily returns, as React's UseFontFamilyReturn.

interface UseFontFamilyReturn

Member	Type	Summary
disabledReason	`ComputedRef<string \| null>`	Why the font cannot change: a catalog key, or the engine's own text.
groups	`ComputedRef<readonly FontPickerGroup[]>`	The packaged picker's groups for the current slide, empty groups left out: the theme fonts (labeled Headings and Body), the other families the deck names, then all families.
isCurrent	`(row: FontPickerRow) => boolean`	Whether a row is the font the selected text uses, for a check mark.
isEnabled	`ComputedRef<boolean>`	Whether the engine can change the font now.
options	`ComputedRef<readonly string[]>`	Every family the editor offers: standard, configured, embedded, and the deck's own.
setValue	`(family: string) => void`	Apply a family, or a theme font reference (`+mj-lt`, `+mn-lt`) so the text follows a later theme change. A refusal does nothing.
theme	`ComputedRef<'major' \| 'minor' \| null>`	The theme font the selected text uses (`major` for the headings font, `minor` for the body font), or null when it names a family.
value	`ComputedRef<string \| null>`	The family of the selected text, or null for a mixed selection or no selection.

`UseFontFormatReturn`interfaceSource ↗

What useFontFormat returns.

interface UseFontFormatReturn

Member	Type	Summary
apply	`(update: FontFormatCommand) => boolean`	Write the given fields as ONE undo step. Returns whether the engine accepted them.
format	`UseEditorStateReturn<FontFormatRead \| null>`	The font of the selected text, or of every run of the selected shapes; null with none.
isEnabled	`ComputedRef<boolean>`	Whether the engine can write font formatting now (text or a shape with text selected, editable).

`UseHistoryGroupReturn`interfaceSource ↗

What [useHistoryGroup](useHistoryGroup) returns, as React's UseHistoryGroupReturn.

interface UseHistoryGroupReturn

Member	Type	Summary
options	`() => EditorExecOptions`	The options for each command of the gesture: `{ historyGroup }`.
ref	`(element: unknown) => void`	Put it on the control as a function ref: the slider, the stepper, or the color input.

`UseHyperlinkPopupReturn`interfaceSource ↗

What useHyperlinkPopup returns, the twin of React's, with the state as a ref.

interface UseHyperlinkPopupReturn extends HyperlinkPopupActions

Member	Type	Summary
state	`ComputedRef<HyperlinkPopupState>`	Whether the popup shows, what it shows, and the draft.

`UseNotesPaneReturn`interfaceSource ↗

What useNotesPane returns.

interface UseNotesPaneReturn

Member	Type	Summary
open	`ComputedRef<boolean>`	Whether the notes pane shows its text.
setOpen	`(open: boolean) => void`	Show or hide the notes text. A controlled pane gets the change through its handler.
toggle	`() => void`	Show the notes text when hidden, and hide it when shown.

`UseOpenFailureOptions`interfaceSource ↗

Options for useOpenFailure, the twin of React's UseOpenFailureOptions.

interface UseOpenFailureOptions

Member	Type	Summary
t?	`ChromeTranslate`	Your translation function for `message`. Without it, the root's `locale` gives it.

`UseOpenFailureReturn`interfaceSource ↗

What useOpenFailure returns, the twin of React's UseOpenFailureReturn.

interface UseOpenFailureReturn

Member	Type	Summary
dismiss		Hide this refusal. A later refusal shows again, even for the same file. Pass the failure your UI showed, so a late call cannot hide a newer refusal.
failure	`ComputedRef<DocumentOpenFailure \| null>`	The refused open, or `null` when there is none or the person dismissed it.
kept	`ComputedRef<boolean>`	Whether the deck that was open before stays open.
message	`ComputedRef<string \| null>`	The packaged, translated message for `failure`.

`UseParagraphFormatReturn`interfaceSource ↗

What useParagraphFormat returns.

interface UseParagraphFormatReturn

Member	Type	Summary
apply	`(update: ParagraphFormatCommand) => boolean`	Write the given fields as ONE undo step. Returns whether the engine accepted them.
format	`UseEditorStateReturn<ParagraphFormatRead \| null>`	The selected paragraphs' formatting, or null when no text is selected.
isEnabled	`ComputedRef<boolean>`	Whether the engine can write paragraph formatting now (text or a shape with text selected, editable).

`UsePptxSourceReturn`interfaceSource ↗

What usePptxSource returns, the twin of React's, with refs.

interface UsePptxSourceReturn

Member	Type	Summary
document	`ComputedRef<Uint8Array \| undefined>`	Bytes for the `document` prop; undefined until they arrive.
error	`ComputedRef<Error \| null>`	Why the presentation could not be opened. A font failure never shows here.
fonts	`ComputedRef<FontConfiguration \| FontResolver \| undefined>`	What to give the `fonts` prop: a configuration, a stable resolver, or undefined.
isLoading	`ComputedRef<boolean>`	True until the presentation arrives or fails, and while eager fonts load.

`UseSlideshowReturn`interfaceSource ↗

The slide show of the editor in PptxEditorRoot, the twin of React's UseSlideshowReturn. The running show is a ref, so a template reads it reactively.

interface UseSlideshowReturn

Member	Type	Summary
controller	`Readonly<ShallowRef<SlideshowController \| null>>`	The running show, or null. `PptxEditorSlideshow` paints it.
start		Start the show from the first shown slide or from the current slide. Does nothing without an open document with slides. Viewing mode can present.
stop		Close the show.

`UseToolbarContextReturn`interfaceSource ↗

What [useToolbarContext](useToolbarContext) returns, as React's ToolbarContextValue.

interface UseToolbarContextReturn

Member	Type	Summary
t	`Readonly<ShallowRef<ChromeTranslate \| undefined>>`	The host's `t` on the nearest compound, or undefined.

`UseTranslationReturn`interfaceSource ↗

What useTranslation returns.

interface UseTranslationReturn

Member	Type	Summary
t	`Translate`	Translate a key, with shortcut text for this platform. Reactive to the `locale` prop.

`UseZoomReturn`interfaceSource ↗

What [useZoom](useZoom) returns: React's UseZoomReturn, with refs for the state.

interface UseZoomReturn

Member	Type	Summary
canZoomIn	`ComputedRef<boolean>`	Whether `zoomIn` can step.
canZoomOut	`ComputedRef<boolean>`	Whether `zoomOut` can step.
fit	`() => void`	Fit the slide to the window, and keep it fitted when the window changes size.
isFit	`ComputedRef<boolean>`	Whether the editor fits the slide to the window and follows its size.
levels	`readonly number[]`	The steps the zoom buttons move through, so a custom control shows the same levels.
reset	`() => void`	A fixed 100 %.
setZoom	`(zoom: number) => void`	Set a fixed zoom, kept in the range 10 % to 400 %. Leaves fit mode.
zoom	`ComputedRef<number>`	The zoom in force. 1 is 100 %. In fit mode it is the zoom that fits the slide.
zoomIn	`() => void`	One step of `levels` in from the zoom in force. Does nothing at 400 %.
zoomOut	`() => void`	One step of `levels` out from the zoom in force. Does nothing at 10 %.

Type aliases (118)

`BackgroundDialogFieldName`typeSource ↗

The field names of the Background dialog, for BackgroundDialog.Field: one per fill kind (SlideBackground['kind']), and Apply to all slides.

type BackgroundDialogFieldName = 'solid' | 'gradient' | 'pattern' | 'picture' | 'allSlides';

`BackgroundDialogProps`typeSource ↗

Props of BackgroundDialog, the twin of React's BackgroundDialogProps.

type BackgroundDialogProps = ExtractPublicPropTypes<typeof backgroundDialogProps>;

`BulletsAndNumberingDialogFieldName`typeSource ↗

The field names of the Bullets and Numbering dialog, for BulletsAndNumberingDialog.Field: the fields of a whole tab (bullet, number), or one field, named as its input: style, char, font, picture, sizePercent, and color on the Bulleted tab; numberStyle, numberSizePercent, numberColor, and startAt on the Numbered tab.

type BulletsAndNumberingDialogFieldName = 'bullet' | 'number' | 'style' | 'char' | 'font' | 'picture' | 'sizePercent' | 'color' | 'numberStyle' | 'numberSizePercent' | 'numberColor' | 'startAt';

`BulletsAndNumberingDialogProps`typeSource ↗

Props of BulletsAndNumberingDialog, the twin of React's BulletsAndNumberingDialogProps.

type BulletsAndNumberingDialogProps = ExtractPublicPropTypes<typeof bulletsAndNumberingDialogProps>;

`ColumnsDialogFieldName`typeSource ↗

The field names of the Columns dialog, for ColumnsDialog.Field: both fields (columns), or one of them, named as its ColumnsDialogFields key.

type ColumnsDialogFieldName = 'columns' | 'count' | 'spacing';

`ColumnsDialogProps`typeSource ↗

Props of ColumnsDialog, the twin of React's ColumnsDialogProps.

type ColumnsDialogProps = ExtractPublicPropTypes<typeof columnsDialogProps>;

`ContextMenuNamedRows`typeSource ↗

The named rows of the canvas context menu (PptxEditorContextMenu.Cut, …), the twin of React's ContextMenuNamedRows.

type ContextMenuNamedRows = {
    readonly [K in ContextMenuPartName]: MenuRowPartComponent;
};

`ContextMenuNamespace`typeSource ↗

The canvas context menu with its parts as statics, the twin of React's.

type ContextMenuNamespace = typeof ContextMenuRoot & ContextMenuNamedRows & {
    readonly Slot: typeof MenuSlotItem;
    readonly Item: typeof MenuRow;
    readonly Group: typeof MenuGroup;
    readonly Separator: typeof MenuSeparator;
    readonly Submenu: typeof MenuSubmenu;
};

`ContextMenuProps`typeSource ↗

Props of ContextMenu, the twin of React's ContextMenuProps. className (or a host class) lands on the menu; the default slot is its rows.

type ContextMenuProps = ExtractPublicPropTypes<typeof contextMenuProps>;

`EditNoticeProps`typeSource ↗

The props of PptxEditorEditNotice, the same name as React's EditNoticeProps.

type EditNoticeProps = ExtractPublicPropTypes<typeof pptxEditorEditNoticeProps>;

`EquationDialogFieldName`typeSource ↗

The field names of the Equation dialog, for EquationDialog.Field.

type EquationDialogFieldName = 'gallery' | 'linear';

`EquationDialogProps`typeSource ↗

Props of EquationDialog, the twin of React's EquationDialogProps.

type EquationDialogProps = ExtractPublicPropTypes<typeof equationDialogProps>;

`FillControlProps`typeSource ↗

The props of FillControl, the twin of React's FillControlProps.

type FillControlProps = ExtractPublicPropTypes<typeof slotPartProps$1>;

`FindBarProps`typeSource ↗

The props of PptxEditorFindBar, the same name as React's FindBarProps.

type FindBarProps = ExtractPublicPropTypes<typeof pptxEditorFindBarProps>;

`FontDialogFieldName`typeSource ↗

The field names of the Font dialog, for FontDialog.Field: a section of the Font tab (allText, effects) or one field, named as its FontDialogFields key, on either tab.

type FontDialogFieldName = 'allText' | 'effects' | 'fontFamily' | 'style' | 'size' | 'color' | 'underline' | 'underlineColor' | 'strike' | 'doubleStrike' | 'superscript' | 'offset' | 'subscript' | 'smallCaps' | 'allCaps' | 'spacing' | 'by' | 'kerning' | 'kerningAt';

`FontDialogProps`typeSource ↗

Props of FontDialog, the twin of React's FontDialogProps.

type FontDialogProps = ExtractPublicPropTypes<typeof fontDialogProps>;

`FontFamilyItemProps`typeSource ↗

Props of PptxEditorToolbar.FontFamily.Item, as React's.

type FontFamilyItemProps = ExtractPublicPropTypes<typeof fontFamilyItemProps>;

`FontFamilyNamespace`typeSource ↗

PptxEditorToolbar.FontFamily: the font.family picker, as DOCX Editor's FontFamily compound. With no slot content it renders the default trigger and list; with slot content, compose the Trigger, Content, and Item parts around the shared state.

type FontFamilyNamespace = DefineComponent<FontFamilyProps> & {
    readonly pptxSlot: ChromeSlotId;
    readonly Trigger: DefineComponent<FontFamilyPartProps>;
    readonly Content: DefineComponent<FontFamilyPartProps>;
    readonly Item: DefineComponent<FontFamilyItemProps>;
};

`FontFamilyPartProps`typeSource ↗

Props of PptxEditorToolbar.FontFamily.Trigger and .Content, as React's. The default slot replaces the part's default content.

type FontFamilyPartProps = ExtractPublicPropTypes<typeof fontFamilyPartProps>;

`FontFamilyProps`typeSource ↗

Props of PptxEditorToolbar.FontFamily, as React's FontFamilyProps: a picker part's className and hidden; its default slot composes the Trigger, Content, and Item parts.

type FontFamilyProps = ToolbarSlotPartProps;

`FontNoticeProps`typeSource ↗

The props of PptxEditorFontNotice, the same name as React's FontNoticeProps.

type FontNoticeProps = ExtractPublicPropTypes<typeof pptxEditorFontNoticeProps>;

`FontsInput`typeSource ↗

The first argument of useFonts: a FontConfiguration, a fragment, a FontResolver (such as packagedFonts()), a promise of a configuration or a fragment, or undefined. Each may be a ref or a getter, which useFonts reads again at each resolve.

type FontsInput = FontConfiguration | FontConfigurationFragment | FontResolver | Promise<FontConfiguration | FontConfigurationFragment | undefined> | undefined;

`GradientDialogProps`typeSource ↗

Props of GradientDialog, the twin of React's GradientDialogProps.

type GradientDialogProps = ExtractPublicPropTypes<typeof gradientDialogProps>;

`HyperLinkActionProps`typeSource ↗

Props of the action parts; the glyph is the icon slot.

type HyperLinkActionProps = HyperLinkPartProps;

`HyperLinkPartProps`typeSource ↗

Shared props of every part, the twin of React's HyperLinkPartProps.

type HyperLinkPartProps = ExtractPublicPropTypes<typeof partProps$2>;

`HyperlinkPopupProps`typeSource ↗

What a replacement link popup receives, the twin of React's HyperlinkPopupProps.

type HyperlinkPopupProps = ExtractPublicPropTypes<typeof hyperlinkPopupProps>;

`HyperLinkProps`typeSource ↗

Props of PptxEditorHyperLink.

type HyperLinkProps = ExtractPublicPropTypes<typeof rootProps>;

`IconProps`typeSource ↗

The props of Icon, the twin of React's IconProps.

type IconProps = ExtractPublicPropTypes<typeof iconProps>;

`ImageAltTextDialogFieldName`typeSource ↗

The field names of the Alt Text dialog, for ImageAltTextDialog.Field.

type ImageAltTextDialogFieldName = 'description' | 'title' | 'decorative';

`ImageAltTextDialogProps`typeSource ↗

Props of ImageAltTextDialog, the twin of React's ImageAltTextDialogProps.

type ImageAltTextDialogProps = ExtractPublicPropTypes<typeof imageAltTextDialogProps>;

`ImagePropertiesDialogFieldName`typeSource ↗

The field names of the Format Picture dialog, for ImagePropertiesDialog.Field.

type ImagePropertiesDialogFieldName = 'size' | 'rotation' | 'crop';

`ImagePropertiesDialogProps`typeSource ↗

Props of ImagePropertiesDialog, the twin of React's ImagePropertiesDialogProps.

type ImagePropertiesDialogProps = ExtractPublicPropTypes<typeof imagePropertiesDialogProps>;

`LayoutGalleryProps`typeSource ↗

Props of LayoutGallery, the twin of React's LayoutGalleryProps.

type LayoutGalleryProps = ExtractPublicPropTypes<typeof layoutGalleryProps>;

`LineGlyphProps`typeSource ↗

The props of LineGlyph, the twin of React's LineGlyphProps.

type LineGlyphProps = ExtractPublicPropTypes<typeof lineGlyphProps>;

`LineMenuControlProps`typeSource ↗

The props of LineMenuControl, the twin of React's LineMenuControlProps.

type LineMenuControlProps = ExtractPublicPropTypes<typeof slotPartProps$1>;

`LoadingProps`typeSource ↗

Props of PptxEditorLoading, the same name as React's LoadingProps.

type LoadingProps = ExtractPublicPropTypes<typeof loadingProps>;

`LoadingSpinnerProps`typeSource ↗

Props of PptxEditorLoadingSpinner, the twin of React's LoadingSpinnerProps.

type LoadingSpinnerProps = ExtractPublicPropTypes<typeof loadingSpinnerProps>;

`MenuEntryProps`typeSource ↗

Props for PptxEditorMenu.Entry, the twin of React's MenuEntryProps. className (or a host class) goes onto the menu's panel; the default slot is the menu's rows.

type MenuEntryProps = ExtractPublicPropTypes<typeof menuEntryProps>;

`MenuGroupProps`typeSource ↗

Props for PptxEditorMenu.Group, the twin of React's MenuGroupProps.

type MenuGroupProps = ExtractPublicPropTypes<typeof menuGroupProps>;

`MenuNamedRows`typeSource ↗

The named rows of the menu bar (PptxEditorMenu.Cut, PptxEditorMenu.PageSetup, …), the twin of React's MenuNamedRows.

type MenuNamedRows = {
    readonly [K in MenuRowPartName]: MenuRowPartComponent;
};

`MenuNamespace`typeSource ↗

The menu bar with its parts as statics, the twin of React's MenuNamespace.

type MenuNamespace = typeof MenuRoot & MenuNamedRows & {
    readonly Entry: typeof MenuEntry;
    readonly Item: typeof MenuSlotItem;
    readonly Row: typeof MenuRow;
    readonly Group: typeof MenuGroup;
    readonly Separator: typeof MenuSeparator;
    readonly Submenu: typeof MenuSubmenu;
    readonly TableGrid: typeof MenuTableGrid;
    readonly File: MenuPartComponent;
    readonly Edit: MenuPartComponent;
    readonly View: MenuPartComponent;
    readonly Insert: MenuPartComponent;
    readonly Format: MenuPartComponent;
    readonly Arrange: MenuPartComponent;
    readonly SlideShow: MenuPartComponent;
};

`MenuPartComponent`typeSource ↗

A named menu (PptxEditorMenu.File): a MenuEntry with its id pinned.

type MenuPartComponent = DefineComponent<MenuPartProps> & {
    readonly pptxMenu: ChromeMenuId;
};

`MenuProps`typeSource ↗

Props for PptxEditorMenu, the twin of React's MenuProps. className (or a host class) lands on the bar; the default slot holds the named menus, MenuEntry children, and other bar content.

type MenuProps = ExtractPublicPropTypes<typeof menuProps>;

`MenuRowPartComponent`typeSource ↗

A named menu row: a MenuSlotItem with its slot pinned, as React's.

type MenuRowPartComponent = DefineComponent<MenuRowPartProps> & {
    readonly pptxMenuRow: MenuNamedRow;
};

`MenuRowPartProps`typeSource ↗

Props for a named menu row, the twin of React's MenuRowPartProps.

type MenuRowPartProps = ExtractPublicPropTypes<typeof menuRowPartProps>;

`MenuRowProps`typeSource ↗

Props of MenuRow, the twin of React's MenuRowProps.

type MenuRowProps = ExtractPublicPropTypes<typeof menuRowProps>;

`MenuSlotItemProps`typeSource ↗

Props for PptxEditorMenu.Item and PptxEditorContextMenu.Slot: one registry row, the twin of React's MenuSlotItemProps. className (or a host class) lands on the row.

type MenuSlotItemProps = ExtractPublicPropTypes<typeof menuSlotItemProps>;

`MenuSubmenuProps`typeSource ↗

Props of MenuSubmenu, the twin of React's MenuSubmenuProps.

type MenuSubmenuProps = ExtractPublicPropTypes<typeof menuSubmenuProps>;

`MenuTableGridProps`typeSource ↗

Props of MenuTableGrid, the twin of React's MenuTableGridProps.

type MenuTableGridProps = ExtractPublicPropTypes<typeof menuTableGridProps>;

`NotesPaneProps`typeSource ↗

Props of PptxEditorNotesPane, the twin of React's NotesPaneProps: the pane props, without a width (the notes take the slide's width), and the format buttons. className (or a host class) and style go on the pane.

type NotesPaneProps = ExtractPublicPropTypes<typeof notesPaneProps>;

`PageSetupDialogFieldName`typeSource ↗

The field names of the Page setup dialog, for PageSetupDialogField.

type PageSetupDialogFieldName = 'slideSize' | 'theme' | 'fonts' | 'substitutes';

`PageSetupDialogProps`typeSource ↗

Props of PageSetupDialog, the twin of React's PageSetupDialogProps.

type PageSetupDialogProps = ExtractPublicPropTypes<typeof pageSetupDialogProps>;

`PaneProps`typeSource ↗

Props of the editor's panes, the twin of React's PaneProps. A host class and style go on the pane; a width in style wins over paneWidth.

type PaneProps = ExtractPublicPropTypes<typeof paneProps>;

`ParagraphDialogFieldName`typeSource ↗

The field names of the Paragraph dialog, for ParagraphDialog.Field: a section (general, indentation, spacing) or one field in it, named as its ParagraphDialogFields key. A spacing field holds its unit list.

type ParagraphDialogFieldName = 'general' | 'indentation' | 'spacing' | 'alignment' | 'indentLeft' | 'special' | 'specialBy' | 'spaceBefore' | 'spaceAfter' | 'lineRule' | 'lineAt';

`ParagraphDialogProps`typeSource ↗

Props of ParagraphDialog, the twin of React's ParagraphDialogProps.

type ParagraphDialogProps = ExtractPublicPropTypes<typeof paragraphDialogProps>;

`PatternDialogProps`typeSource ↗

Props of PatternDialog, the twin of React's PatternDialogProps.

type PatternDialogProps = ExtractPublicPropTypes<typeof patternDialogProps>;

`PptxEditorContentProps`typeSource ↗

The props of PptxEditorContent, the twin of React's PptxEditorContentProps.

type PptxEditorContentProps = ExtractPublicPropTypes<typeof pptxEditorContentProps>;

`PptxEditorContextMenuProps`typeSource ↗

Props for PptxEditorContextMenu, the twin of React's PptxEditorContextMenuProps. className (or a host class) lands on the menu; the default slot holds the host's rows.

type PptxEditorContextMenuProps = ExtractPublicPropTypes<typeof pptxEditorContextMenuProps>;

`PptxEditorDialogKey`typeSource ↗

The dialogs the registry mounts.

type PptxEditorDialogKey = Exclude<keyof PptxEditorPopups, MenuPopupKey | OverlayPopupKey>;

`PptxEditorOpenFailureProps`typeSource ↗

Props of PptxEditorOpenFailure, the same name as React's. onDismiss is the listener of the dismiss event, so the openFailure object on PptxEditor can carry it.

type PptxEditorOpenFailureProps = ExtractPublicPropTypes<typeof openFailureProps> & {
    readonly onDismiss?: (failure: DocumentOpenFailure) => void;
};

`PptxEditorPopup`typeSource ↗

A render callback for an automatic popup. false disables automatic rendering.

type PptxEditorPopup<Props extends object> = false | ((props: Props) => VNodeChild);

`PptxEditorProps`typeSource ↗

Props of the PptxEditor sugar component, the twin of React's PptxEditorProps. Derived from the component's runtime props, so the two cannot drift.

type PptxEditorProps = ExtractPublicPropTypes<typeof pptxEditorProps>;

`PptxEditorRootProps`typeSource ↗

Props of PptxEditorRoot, the twin of React's PptxEditorRootProps.

type PptxEditorRootProps = ExtractPublicPropTypes<typeof pptxEditorRootProps>;

`PptxEditorToolbarNamespace`typeSource ↗

The statics of PptxEditorToolbar, the twin of React's ToolbarNamespace: Slot, Group, Action, Separator, and the named parts.

type PptxEditorToolbarNamespace = typeof ToolbarRoot & NamedParts & {
    readonly Slot: typeof ToolbarSlot;
    readonly Group: typeof ToolbarGroup;
    readonly Action: typeof ToolbarAction;
    readonly Separator: typeof ToolbarSeparator;
};

`PptxEditorViewportProps`typeSource ↗

The props of PptxEditorViewport, the twin of React's PptxEditorViewportProps.

type PptxEditorViewportProps = ExtractPublicPropTypes<typeof pptxEditorViewportProps>;

`RailContextMenuProps`typeSource ↗

Props of the context menu of a slide in the rail or the sorter, and of a popups.railContextMenu renderer, the twin of React's RailContextMenuProps.

type RailContextMenuProps = ExtractPublicPropTypes<typeof railContextMenuProps>;

`RibbonProps`typeSource ↗

Props of PptxEditorRibbon, the twin of React's RibbonProps.

type RibbonProps = ExtractPublicPropTypes<typeof ribbonProps>;

`RibbonTabProps`typeSource ↗

Props of RibbonTab, the twin of React's RibbonTabProps.

type RibbonTabProps = ExtractPublicPropTypes<typeof ribbonTabProps>;

`SectionContextMenuProps`typeSource ↗

Props of the section menu, and of a popups.sectionContextMenu renderer, the twin of React's SectionContextMenuProps.

type SectionContextMenuProps = ExtractPublicPropTypes<typeof sectionContextMenuProps>;

`SelectionPaneProps`typeSource ↗

Props of PptxEditorSelectionPane, the twin of React's SelectionPaneProps.

type SelectionPaneProps = ExtractPublicPropTypes<typeof selectionPaneProps>;

`ShapeGalleryControlProps`typeSource ↗

The props of ShapeGalleryControl, the twin of React's ShapeGalleryControlProps.

type ShapeGalleryControlProps = ExtractPublicPropTypes<typeof slotPartProps$1>;

`ShapeGridProps`typeSource ↗

The props of ShapeGrid, the twin of React's ShapeGridProps.

type ShapeGridProps = ExtractPublicPropTypes<typeof shapeGridProps>;

`ShapeIconProps`typeSource ↗

The props of ShapeIcon, the twin of React's ShapeIconProps.

type ShapeIconProps = ExtractPublicPropTypes<typeof shapeIconProps>;

`ShapeStyleGalleryProps`typeSource ↗

Props of ShapeStyleGallery, the twin of React's ShapeStyleGalleryProps.

type ShapeStyleGalleryProps = ExtractPublicPropTypes<typeof shapeStyleGalleryProps>;

`SidePanelProps`typeSource ↗

Props of PptxEditorSidePanel, the twin of React's SidePanelProps. onClose shows a close button that calls it; className (or a host class) and style go on the panel, and a width in style wins over paneWidth.

type SidePanelProps = ExtractPublicPropTypes<typeof sidePanelProps>;

`SlideRailPartProps`typeSource ↗

Props of every named part of the slide rail's action row, the twin of React's SlideRailPartProps.

type SlideRailPartProps = ExtractPublicPropTypes<typeof partProps$1>;

`SlideRailProps`typeSource ↗

Props of PptxEditorSlideRail, the twin of React's SlideRailProps.

type SlideRailProps = ExtractPublicPropTypes<typeof slideRailProps>;

`SlideSorterProps`typeSource ↗

Props of PptxEditorSlideSorter, the twin of React's SlideSorterProps.

type SlideSorterProps = ExtractPublicPropTypes<typeof slideSorterProps>;

`StatusBarNotesProps`typeSource ↗

Props of StatusBarNotes, the twin of React's StatusBarNotesProps: the part props, and the ladder's icon and asChild (the element goes in the default slot). className (or a host class) goes on the button.

type StatusBarNotesProps = ExtractPublicPropTypes<typeof notesPartProps>;

`StatusBarPartProps`typeSource ↗

Props of every status bar part: hidden, and className (or class) on the part.

type StatusBarPartProps = ExtractPublicPropTypes<typeof partProps>;

`StatusBarProps`typeSource ↗

Props of PptxEditorStatusBar, the twin of React's StatusBarProps.

type StatusBarProps = ExtractPublicPropTypes<typeof statusBarProps>;

`ToolbarActionProps`typeSource ↗

Props of ToolbarAction, the twin of React's ToolbarActionProps.

type ToolbarActionProps = ExtractPublicPropTypes<typeof toolbarActionProps>;

`ToolbarColorSplitComponent`typeSource ↗

A named color split part: a component with its slot as a static.

type ToolbarColorSplitComponent = DefineComponent<ToolbarColorSplitProps> & {
    readonly pptxSlot: ChromeSlotId;
};

`ToolbarColorSplitProps`typeSource ↗

Props of the named color split parts (PptxEditorToolbar.FontColor, Highlight, ShapeFill, LineColor, TableCellFill), as DOCX Editor's ToolbarColorSplitProps: the main half takes an icon (the glyph over the color bar).

type ToolbarColorSplitProps = ExtractPublicPropTypes<typeof toolbarColorSplitProps>;

`ToolbarControlProps`typeSource ↗

The props of ToolbarControl, the twin of React's ToolbarControlProps.

type ToolbarControlProps = ExtractPublicPropTypes<typeof toolbarControlProps>;

`ToolbarGroupProps`typeSource ↗

Props of ToolbarGroup, the twin of React's ToolbarGroupProps.

type ToolbarGroupProps = ExtractPublicPropTypes<typeof toolbarGroupProps>;

`ToolbarPartComponent`typeSource ↗

A named button part: a component with its slot as a static.

type ToolbarPartComponent = DefineComponent<ToolbarPartProps> & {
    readonly pptxSlot: ChromeSlotId;
};

`ToolbarPartProps`typeSource ↗

Props of the named button parts (PptxEditorToolbar.Bold, PptxEditorToolbar.Undo, …), as React's and DOCX Editor's: the slot is pinned, and the default slot is icon content (icon, else the default slot, else the registry icon), not a replacement. With asChild, the one default-slot element renders the control.

type ToolbarPartProps = ExtractPublicPropTypes<typeof toolbarPartProps>;

`ToolbarProps`typeSource ↗

Props of PptxEditorToolbar, the twin of React's ToolbarProps.

type ToolbarProps = ExtractPublicPropTypes<typeof pptxEditorToolbarProps>;

`ToolbarSeparatorProps`typeSource ↗

Props of ToolbarSeparator, the twin of React's ToolbarSeparatorProps.

type ToolbarSeparatorProps = ExtractPublicPropTypes<typeof toolbarSeparatorProps>;

`ToolbarSlotPartComponent`typeSource ↗

A named picker part: a component with its slot as a static.

type ToolbarSlotPartComponent = DefineComponent<ToolbarSlotPartProps> & {
    readonly pptxSlot: ChromeSlotId;
};

`ToolbarSlotPartProps`typeSource ↗

Props of the named picker parts (PptxEditorToolbar.FontFamily, …), as DOCX Editor's slot parts: a picker is not one button, so it takes no icon, asChild, or slot content.

type ToolbarSlotPartProps = ExtractPublicPropTypes<typeof toolbarSlotPartProps>;

`ToolbarSlotProps`typeSource ↗

Props of ToolbarSlot, the twin of React's ToolbarSlotProps.

type ToolbarSlotProps = ExtractPublicPropTypes<typeof toolbarSlotProps>;

`UseBulletsAndNumberingDialogReturn`typeSource ↗

The Bullets and Numbering draft and its actions, for a host's own field.

type UseBulletsAndNumberingDialogReturn = UseDialogReturn<BulletsDialogFields>;

`UseChromeTranslateReturn`typeSource ↗

What [useChromeTranslate](useChromeTranslate) returns: the translation function.

type UseChromeTranslateReturn = ChromeTranslate;

`UseColumnsDialogReturn`typeSource ↗

The Columns draft and its actions, for a host's own field inside the dialog.

type UseColumnsDialogReturn = UseDialogReturn<ColumnsDialogFields>;

`UseContextMenuRequestReturn`typeSource ↗

What useContextMenuRequest returns: the open request, or null.

type UseContextMenuRequestReturn = ContextMenuRequest | null;

`UseContextMenuTargetReturn`typeSource ↗

What useContextMenuTarget returns: the element the menu opened on, or null.

type UseContextMenuTargetReturn = HTMLElement | null;

`UseEditorCaretReturn`typeSource ↗

What [useEditorCaret](useEditorCaret) returns: the caret, or null.

type UseEditorCaretReturn = Readonly<ShallowRef<EditorCaret | null>>;

`UseEditorEventReturn`typeSource ↗

What [useEditorEvent](useEditorEvent) returns: nothing; the subscription ends with the scope.

type UseEditorEventReturn = void;

`UseEditorHostDocumentReturn`typeSource ↗

What useEditorHostDocument returns: a read-only ref to the host document.

type UseEditorHostDocumentReturn = Readonly<ShallowRef<Document | null>>;

`UseEditorSnapshotReturn`typeSource ↗

What [useEditorSnapshot](useEditorSnapshot) returns: the change counter.

type UseEditorSnapshotReturn = Readonly<Ref<number>>;

`UseEditorStateReturn`typeSource ↗

What useEditorState returns: the selected slice, updated when it changes.

type UseEditorStateReturn<T> = Readonly<ShallowRef<T>>;

`UseEquationDialogReturn`typeSource ↗

The Equation draft and its actions.

type UseEquationDialogReturn = UseDialogReturn<EquationDialogFields>;

`UseFontDialogReturn`typeSource ↗

The Font draft and its actions, for a host's own field inside the dialog.

type UseFontDialogReturn = UseDialogReturn<FontDialogFields>;

`UseFontsReturn`typeSource ↗

What useFonts returns: one marked resolver for the component's life. Named for the adapters' composable parity check (PPTX Editor addition).

type UseFontsReturn = MarkedFontResolver;

`UseHyperlinkPopupInstanceReturn`typeSource ↗

What useHyperlinkPopupInstance returns: the same shape as useHyperlinkPopup.

type UseHyperlinkPopupInstanceReturn = UseHyperlinkPopupReturn;

`UseImageAltTextDialogReturn`typeSource ↗

The Alt Text draft and its actions.

type UseImageAltTextDialogReturn = UseDialogReturn<ImageAltTextDialogFields>;

`UseImagePropertiesDialogReturn`typeSource ↗

The Format Picture draft and its actions.

type UseImagePropertiesDialogReturn = UseDialogReturn<ImagePropertiesDialogFields>;

`UsePageSetupDialogReturn`typeSource ↗

The Page setup draft and its actions.

type UsePageSetupDialogReturn = UseDialogReturn<PageSetupDialogFields>;

`UseParagraphDialogReturn`typeSource ↗

The Paragraph draft and its actions, for a host's own field inside the dialog.

type UseParagraphDialogReturn = UseDialogReturn<ParagraphDialogFields>;

`UsePptxEditorReturn`typeSource ↗

What usePptxEditor returns: the editor, or null before PptxEditorRoot mounts it.

type UsePptxEditorReturn = Readonly<ShallowRef<PptxEditorInstance | null>>;

`UseReviewAuthorsReturn`typeSource ↗

What useReviewAuthors returns: the deck's review authors.

type UseReviewAuthorsReturn = UseEditorStateReturn<readonly ReviewAuthorInfo[]>;

`UseScopeClassNameReturn`typeSource ↗

What [useScopeClassName](useScopeClassName) returns.

type UseScopeClassNameReturn = ComputedRef<'' | 'pptx-editor ' | 'pptx-editor dark '>;

`UseSlideLayoutsReturn`typeSource ↗

What useSlideLayouts returns: the deck's slide layouts.

type UseSlideLayoutsReturn = UseEditorStateReturn<readonly SlideLayoutSummary[]>;

`UseToolbarLabelForReturn`typeSource ↗

What [useToolbarLabelFor](useToolbarLabelFor) and [useToolbarLabel](useToolbarLabel) return.

type UseToolbarLabelForReturn = (key: string) => string;

`UseToolbarLabelReturn`typeSource ↗

What [useToolbarLabel](useToolbarLabel) returns.

type UseToolbarLabelReturn = UseToolbarLabelForReturn;

`ZoomPillProps`typeSource ↗

Props of PptxEditorZoomPill, the twin of React's ZoomPillProps.

type ZoomPillProps = ExtractPublicPropTypes<typeof zoomPillProps>;

Variables (75)

`BackgroundDialog`constSource ↗

Change the slide background, with replaceable parts (Header, Title, Body, Footer, Field, Error, Reset, Apply, Cancel), as React's BackgroundDialog. Renders nothing while open is false.

BackgroundDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly className: string;
    readonly style: CSSProperties;
    readonly preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Header: vue.DefineComponent<DialogPartProps>;
    Title: vue.DefineComponent<DialogPartProps>;
    Body: vue.DefineComponent<DialogPartProps>;
    Footer: vue.DefineComponent<DialogPartProps>;
    Field: vue.DefineComponent<DialogPartProps & {
        readonly name: BackgroundDialogFieldName;
    }>;
    Error: vue.DefineComponent<DialogPartProps>;
    Reset: vue.DefineComponent<DialogPartProps>;
    Apply: vue.DefineComponent<DialogPartProps>;
    Cancel: vue.DefineComponent<DialogPartProps>;
}

`BulletsAndNumberingDialog`constSource ↗

Format Bullets and Numbering: the bullet or numbering style, size, color, and start number of the selected paragraphs, applied as one undo step, with replaceable parts (Header, Title, Body, Footer, Field, Error, Apply, Cancel), as React's BulletsAndNumberingDialog. Renders nothing while open is false.

BulletsAndNumberingDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly className: string;
    readonly style: CSSProperties;
    readonly preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Header: vue.DefineComponent<DialogPartProps>;
    Title: vue.DefineComponent<DialogPartProps>;
    Body: vue.DefineComponent<DialogPartProps>;
    Footer: vue.DefineComponent<DialogPartProps>;
    Field: vue.DefineComponent<DialogPartProps & {
        readonly name: BulletsAndNumberingDialogFieldName;
    }>;
    Error: vue.DefineComponent<DialogPartProps>;
    Apply: vue.DefineComponent<DialogPartProps>;
    Cancel: vue.DefineComponent<DialogPartProps>;
}

`ColumnsDialog`constSource ↗

Home Columns More Columns: the number of text columns of the selected shapes and the spacing between them, applied as one undo step, with replaceable parts (Header, Title, Body, Footer, Field, Error, Apply, Cancel), as React's ColumnsDialog. Renders nothing while open is false.

ColumnsDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly className: string;
    readonly style: CSSProperties;
    readonly preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Header: vue.DefineComponent<DialogPartProps>;
    Title: vue.DefineComponent<DialogPartProps>;
    Body: vue.DefineComponent<DialogPartProps>;
    Footer: vue.DefineComponent<DialogPartProps>;
    Field: vue.DefineComponent<DialogPartProps & {
        readonly name: ColumnsDialogFieldName;
    }>;
    Error: vue.DefineComponent<DialogPartProps>;
    Apply: vue.DefineComponent<DialogPartProps>;
    Cancel: vue.DefineComponent<DialogPartProps>;
}

`ContextMenu`constSource ↗

A context menu at a point. Closed by Escape (focus returns to where it was), Tab, a click outside, or a window resize. The arrow keys, Home, and End move through the rows.

ContextMenu: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly at: {
        readonly type: PropType<ContextMenuPoint>;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    readonly keyboard: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly owner: {
        readonly type: PropType<HTMLElement | null>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly at: {
        readonly type: PropType<ContextMenuPoint>;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    readonly keyboard: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly owner: {
        readonly type: PropType<HTMLElement | null>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly keyboard: boolean;
    readonly owner: HTMLElement | null;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`EquationDialog`constSource ↗

Insert Equation and Edit Equation: a gallery of common equations and the linear form, with replaceable parts (Header, Title, Body, Footer, Field, Error, Apply, Cancel), as React's EquationDialog. Renders nothing while open is false.

EquationDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly className: string;
    readonly style: CSSProperties;
    readonly preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Header: vue.DefineComponent<DialogPartProps>;
    Title: vue.DefineComponent<DialogPartProps>;
    Body: vue.DefineComponent<DialogPartProps>;
    Footer: vue.DefineComponent<DialogPartProps>;
    Field: vue.DefineComponent<DialogPartProps & {
        readonly name: EquationDialogFieldName;
    }>;
    Error: vue.DefineComponent<DialogPartProps>;
    Apply: vue.DefineComponent<DialogPartProps>;
    Cancel: vue.DefineComponent<DialogPartProps>;
}

`FillControl`constSource ↗

Fill color: one menu with the theme and standard colors, Transparent, gradient presets from the theme colors, a custom gradient dialog, a pattern dialog, and a picture.

FillControl: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly slot: {
        readonly type: PropType<ChromeSlotId>;
        readonly required: true;
    };
    readonly control: {
        readonly type: PropType<ChromeControl>;
        readonly required: true;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly slot: {
        readonly type: PropType<ChromeSlotId>;
        readonly required: true;
    };
    readonly control: {
        readonly type: PropType<ChromeControl>;
        readonly required: true;
    };
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`FontDialog`constSource ↗

Format Font: the font, style, size, underline, effects, character spacing, and kerning of the selected text, applied as one undo step, with replaceable parts (Header, Title, Body, Footer, Field, Error, Apply, Cancel), as React's FontDialog. Renders nothing while open is false.

FontDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly className: string;
    readonly style: CSSProperties;
    readonly preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Header: vue.DefineComponent<DialogPartProps>;
    Title: vue.DefineComponent<DialogPartProps>;
    Body: vue.DefineComponent<DialogPartProps>;
    Footer: vue.DefineComponent<DialogPartProps>;
    Field: vue.DefineComponent<DialogPartProps & {
        readonly name: FontDialogFieldName;
    }>;
    Error: vue.DefineComponent<DialogPartProps>;
    Apply: vue.DefineComponent<DialogPartProps>;
    Cancel: vue.DefineComponent<DialogPartProps>;
}

`GradientDialog`constSource ↗

The custom gradient dialog: type, angle, stops, rotation, and a preview. Calls onClose, and onApply with the gradient.

GradientDialog: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly initial: {
        readonly type: PropType<GradientFill | null>;
        readonly default: null;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly onApply: {
        readonly type: PropType<(gradient: GradientFill) => void>;
        readonly required: true;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly initial: {
        readonly type: PropType<GradientFill | null>;
        readonly default: null;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly onApply: {
        readonly type: PropType<(gradient: GradientFill) => void>;
        readonly required: true;
    };
}>> & Readonly<{}>, {
    readonly initial: GradientFill | null;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`HyperlinkPopup`constSource ↗

The packaged link popup: PptxEditorHyperLink with its default parts. A popups.hyperlink renderer can forward its props to it. A host class goes on the popup panel, as className does.

HyperlinkPopup: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly anchor: {
        readonly type: PropType<HTMLElement | null>;
        readonly required: true;
    };
    readonly url: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    readonly mode: {
        readonly type: PropType<"reading" | "editing">;
        readonly default: undefined;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly anchor: {
        readonly type: PropType<HTMLElement | null>;
        readonly required: true;
    };
    readonly url: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    readonly mode: {
        readonly type: PropType<"reading" | "editing">;
        readonly default: undefined;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly mode: "reading" | "editing";
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`Icon`constSource ↗

An inline Material Symbol.

Icon: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly name: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly paths: {
        readonly type: PropType<readonly string[] | null>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: "pptx-icon";
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly name: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly paths: {
        readonly type: PropType<readonly string[] | null>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: "pptx-icon";
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly name: string;
    readonly paths: readonly string[] | null;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`ImageAltTextDialog`constSource ↗

Alt text of the selected element: description, title, and "Mark as decorative", with replaceable parts (Header, Title, Body, Footer, Field, Error, Apply, Cancel), as React's ImageAltTextDialog. Renders nothing while open is false.

ImageAltTextDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly className: string;
    readonly style: CSSProperties;
    readonly preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Header: vue.DefineComponent<DialogPartProps>;
    Title: vue.DefineComponent<DialogPartProps>;
    Body: vue.DefineComponent<DialogPartProps>;
    Footer: vue.DefineComponent<DialogPartProps>;
    Field: vue.DefineComponent<DialogPartProps & {
        readonly name: ImageAltTextDialogFieldName;
    }>;
    Error: vue.DefineComponent<DialogPartProps>;
    Apply: vue.DefineComponent<DialogPartProps>;
    Cancel: vue.DefineComponent<DialogPartProps>;
}

`ImagePropertiesDialog`constSource ↗

Format Picture: size, rotation, and crop position of the selected picture, with replaceable parts (Header, Title, Body, Footer, Field, Error, Apply, Cancel), as React's ImagePropertiesDialog. Renders nothing while open is false.

ImagePropertiesDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly className: string;
    readonly style: CSSProperties;
    readonly preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Header: vue.DefineComponent<DialogPartProps>;
    Title: vue.DefineComponent<DialogPartProps>;
    Body: vue.DefineComponent<DialogPartProps>;
    Footer: vue.DefineComponent<DialogPartProps>;
    Field: vue.DefineComponent<DialogPartProps & {
        readonly name: ImagePropertiesDialogFieldName;
    }>;
    Error: vue.DefineComponent<DialogPartProps>;
    Apply: vue.DefineComponent<DialogPartProps>;
    Cancel: vue.DefineComponent<DialogPartProps>;
}

`LayoutGallery`constSource ↗

A grid of the deck's layouts, as the Layout and New Slide galleries show them: one group per slide master, headed by its name, and each tile the engine's render of a new slide on the layout, named below. The tiles are menu rows (menuitem, or menuitemradio with value); arrow keys, Home, and End move between them, so the gallery works in any menu or popup of the host. Emits change with the picked layout's id; className (or a host class) goes on the gallery.

LayoutGallery: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly value: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly layouts: {
        readonly type: PropType<readonly SlideLayoutSummary[]>;
        readonly default: undefined;
    };
    readonly disabled: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
    readonly disabledReason: {
        readonly type: PropType<string | null>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    change: (_layoutId: string) => true;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly value: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly layouts: {
        readonly type: PropType<readonly SlideLayoutSummary[]>;
        readonly default: undefined;
    };
    readonly disabled: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
    readonly disabledReason: {
        readonly type: PropType<string | null>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{
    onChange?: ((_layoutId: string) => any) | undefined;
}>, {
    readonly className: string;
    readonly disabled: boolean;
    readonly value: string;
    readonly disabledReason: string | null;
    readonly layouts: readonly SlideLayoutSummary[];
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`LineGlyph`constSource ↗

Glyphs for line kinds, line ends, and preset dashes, drawn in a 48×24 box.

LineGlyph: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly value: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    readonly start: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly value: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    readonly start: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly start: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`LineMenuControl`constSource ↗

The line tool, the line start and end menus, and the dash menus, with each option drawn.

LineMenuControl: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly slot: {
        readonly type: PropType<ChromeSlotId>;
        readonly required: true;
    };
    readonly control: {
        readonly type: PropType<ChromeControl>;
        readonly required: true;
    };
}>, () => (vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null)[] | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly slot: {
        readonly type: PropType<ChromeSlotId>;
        readonly required: true;
    };
    readonly control: {
        readonly type: PropType<ChromeControl>;
        readonly required: true;
    };
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`MenuEntry`constSource ↗

One menu of the bar. Inside PptxEditorMenu it is a description the bar reads; the bar renders it.

MenuEntry: DefineComponent<vue.ExtractPropTypes<{
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly labelKey: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly icon: {
        readonly type: PropType<string | VNode>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
    readonly after: {
        readonly type: PropType<ChromeMenuId | (string & {})>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly id: {
        readonly type: PropType<ChromeMenuId | (string & {})>;
        readonly required: true;
    };
}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly labelKey: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly icon: {
        readonly type: PropType<string | VNode>;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
    readonly after: {
        readonly type: PropType<ChromeMenuId | (string & {})>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly id: {
        readonly type: PropType<ChromeMenuId | (string & {})>;
        readonly required: true;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly preset: boolean;
    readonly label: string;
    readonly hidden: boolean;
    readonly icon: string | VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    readonly after: (string & {}) | ChromeMenuId;
    readonly labelKey: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`MenuGroup`constSource ↗

A labeled set of rows inside a menu. A host class lands on the group.

MenuGroup: DefineComponent<vue.ExtractPropTypes<{
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly labelKey: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly labelKey: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly hidden: boolean;
    readonly labelKey: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`MenuRow`constSource ↗

A menu row: icon, label, and shortcut. A disabled row stays focusable with aria-disabled, so a keyboard or pointer user can read why. Emits select; inside a packaged menu, the menu closes after.

MenuRow: DefineComponent<typeof menuRowProps, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    select: () => true;
}>

`MenuSeparator`constSource ↗

A line between groups of rows.

MenuSeparator: DefineComponent<{}, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`MenuSlotItem`constSource ↗

A menu row for a registered slot: its label, icon, shortcut, enabled state, and action come from the chrome registry. A slot that collects a value opens a submenu of its choices.

MenuSlotItem: DefineComponent<vue.ExtractPropTypes<{
    readonly slotId: {
        readonly type: PropType<ChromeSlotId>;
        readonly required: true;
    };
    readonly value: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly labelKey: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly shortcutKey: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly icon: {
        readonly type: PropType<string | VNode>;
        readonly default: undefined;
    };
    readonly direct: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly slotId: {
        readonly type: PropType<ChromeSlotId>;
        readonly required: true;
    };
    readonly value: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly labelKey: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly shortcutKey: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly icon: {
        readonly type: PropType<string | VNode>;
        readonly default: undefined;
    };
    readonly direct: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly value: string;
    readonly hidden: boolean;
    readonly icon: string | VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    readonly labelKey: string;
    readonly shortcutKey: string;
    readonly direct: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`MenuSubmenu`constSource ↗

A row that opens a cascading panel to its right (to its left at the window's edge). It opens on hover, click, Enter, and ArrowRight, and closes on ArrowLeft and Escape, which give focus back to the row. The default slot is the panel's rows.

MenuSubmenu: DefineComponent<typeof menuSubmenuProps, () => (JSX.Element | null)[], {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}>

`MenuTableGrid`constSource ↗

The Insert Table grid, 10 columns by 8 rows, as DOCX Editor's TableSizeGrid: the cell under the pointer (or focus) picks the size and each cell names it. A grid with one tab stop; the arrows, Home, and End move inside it. onPick runs instead of the insert, with the rows and columns; after an insert it calls onInserted, and without one it closes the surrounding menu. className (or a host class) goes on the grid.

MenuTableGrid: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly slot: {
        readonly type: PropType<ChromeSlotId>;
        readonly default: "table.insert";
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly autoFocus: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly onPick: {
        readonly type: PropType<(rows: number, cols: number) => void>;
    };
    readonly onInserted: {
        readonly type: PropType<() => void>;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly slot: {
        readonly type: PropType<ChromeSlotId>;
        readonly default: "table.insert";
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly autoFocus: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly onPick: {
        readonly type: PropType<(rows: number, cols: number) => void>;
    };
    readonly onInserted: {
        readonly type: PropType<() => void>;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly slot: ChromeSlotId;
    readonly autoFocus: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PageSetupDialog`constSource ↗

Page setup: slide size, appearance, and fonts, with replaceable parts (Header, Title, Body, Footer, Field, Error, Apply, Cancel), as React's PageSetupDialog. Renders nothing while open is false.

PageSetupDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly theme: {
            readonly type: PropType<"light" | "dark">;
            readonly default: "light";
        };
        readonly onThemeChange: {
            readonly type: PropType<(theme: "light" | "dark") => void>;
            readonly default: undefined;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
        readonly theme: "light" | "dark";
        readonly onThemeChange: (theme: "light" | "dark") => void;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly theme: {
            readonly type: PropType<"light" | "dark">;
            readonly default: "light";
        };
        readonly onThemeChange: {
            readonly type: PropType<(theme: "light" | "dark") => void>;
            readonly default: undefined;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
        readonly theme: "light" | "dark";
        readonly onThemeChange: (theme: "light" | "dark") => void;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly theme: {
        readonly type: PropType<"light" | "dark">;
        readonly default: "light";
    };
    readonly onThemeChange: {
        readonly type: PropType<(theme: "light" | "dark") => void>;
        readonly default: undefined;
    };
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly className: string;
    readonly style: CSSProperties;
    readonly preset: boolean;
    readonly theme: "light" | "dark";
    readonly onThemeChange: (theme: "light" | "dark") => void;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Header: vue.DefineComponent<DialogPartProps>;
    Title: vue.DefineComponent<DialogPartProps>;
    Body: vue.DefineComponent<DialogPartProps>;
    Footer: vue.DefineComponent<DialogPartProps>;
    Field: vue.DefineComponent<DialogPartProps & {
        readonly name: PageSetupDialogFieldName;
    }>;
    Error: vue.DefineComponent<DialogPartProps>;
    Apply: vue.DefineComponent<DialogPartProps>;
    Cancel: vue.DefineComponent<DialogPartProps>;
}

`ParagraphDialog`constSource ↗

Format Paragraph: alignment, indents, spacing, and line spacing of the selected paragraphs, applied as one undo step, with replaceable parts (Header, Title, Body, Footer, Field, Error, Apply, Cancel), as React's ParagraphDialog. Renders nothing while open is false.

ParagraphDialog: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly className: string;
    readonly style: CSSProperties;
    readonly preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Header: vue.DefineComponent<DialogPartProps>;
    Title: vue.DefineComponent<DialogPartProps>;
    Body: vue.DefineComponent<DialogPartProps>;
    Footer: vue.DefineComponent<DialogPartProps>;
    Field: vue.DefineComponent<DialogPartProps & {
        readonly name: ParagraphDialogFieldName;
    }>;
    Error: vue.DefineComponent<DialogPartProps>;
    Apply: vue.DefineComponent<DialogPartProps>;
    Cancel: vue.DefineComponent<DialogPartProps>;
}

`PatternDialog`constSource ↗

The pattern fill dialog: a preset, its two colors, and a preview.

PatternDialog: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly initial: {
        readonly type: PropType<PatternFill | null>;
        readonly default: null;
    };
    readonly base: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly onApply: {
        readonly type: PropType<(pattern: PatternFill) => void>;
        readonly required: true;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly required: true;
    };
    readonly initial: {
        readonly type: PropType<PatternFill | null>;
        readonly default: null;
    };
    readonly base: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly onApply: {
        readonly type: PropType<(pattern: PatternFill) => void>;
        readonly required: true;
    };
}>> & Readonly<{}>, {
    readonly base: string;
    readonly initial: PatternFill | null;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditor`constSource ↗

The default editor, with every part on it, the twin of React's PptxEditor namespace and of DOCX Editor's Vue DocxEditor: PptxEditor.Root, PptxEditor.Toolbar, PptxEditor.Menu, and the rest name the same parts as their PptxEditor<Part> exports.

PptxEditor: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly document: {
            readonly type: PropType<Uint8Array>;
            readonly default: undefined;
        };
        readonly mode: {
            readonly type: PropType<EditorMode>;
            readonly default: "edit";
        };
        readonly locale: {
            readonly type: PropType<LocaleCatalog>;
            readonly default: undefined;
        };
        readonly fontFamilies: {
            readonly type: PropType<readonly string[]>;
            readonly default: undefined;
        };
        readonly modules: {
            readonly type: PropType<readonly EditorModule[]>;
            readonly default: undefined;
        };
        readonly autoCorrect: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly readClipboardDrawing: {
            readonly type: PropType<ClipboardDrawingReader>;
            readonly default: undefined;
        };
        readonly author: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly popups: {
            readonly type: PropType<PptxEditorPopups>;
            readonly default: undefined;
        };
        readonly colorMode: {
            readonly type: PropType<ColorMode>;
            readonly default: undefined;
        };
        readonly fonts: {
            readonly type: PropType<EditorFontsOption>;
            readonly default: undefined;
        };
        readonly openFailure: {
            readonly type: PropType<boolean | PptxEditorOpenFailureProps>;
            readonly default: true;
        };
        readonly toolbar: {
            readonly type: PropType<boolean | ToolbarProps>;
            readonly default: true;
        };
        readonly menu: {
            readonly type: PropType<boolean | MenuProps>;
            readonly default: false;
        };
        readonly contextMenu: {
            readonly type: PropType<boolean | PptxEditorContextMenuProps>;
            readonly default: true;
        };
        readonly hyperlinkPopup: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly slideRail: {
            readonly type: PropType<boolean | SlideRailProps>;
            readonly default: true;
        };
        readonly notesPane: {
            readonly type: PropType<boolean | NotesPaneProps>;
            readonly default: true;
        };
    }>> & Readonly<{
        onReady?: ((_editor: PptxEditorInstance) => any) | undefined;
        onChange?: ((_editor: PptxEditorInstance) => any) | undefined;
        onFontError?: ((_error: EditorFontError) => any) | undefined;
    }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
        ready: (_editor: PptxEditorInstance) => true;
        change: (_editor: PptxEditorInstance) => true;
        fontError: (_error: EditorFontError) => true;
    }, vue.PublicProps, {
        readonly document: Uint8Array<ArrayBufferLike>;
        readonly mode: EditorMode;
        readonly locale: LocaleCatalog;
        readonly menu: boolean | MenuProps;
        readonly contextMenu: boolean | PptxEditorContextMenuProps;
        readonly toolbar: boolean | ToolbarProps;
        readonly fonts: EditorFontsOption;
        readonly openFailure: boolean | PptxEditorOpenFailureProps;
        readonly fontFamilies: readonly string[];
        readonly modules: readonly EditorModule[];
        readonly autoCorrect: boolean;
        readonly readClipboardDrawing: ClipboardDrawingReader;
        readonly author: string;
        readonly popups: PptxEditorPopups;
        readonly colorMode: ColorMode;
        readonly hyperlinkPopup: boolean;
        readonly slideRail: boolean | SlideRailProps;
        readonly notesPane: boolean | NotesPaneProps;
    }, true, {}, SlotsType<{
        default?: () => VNodeChild;
        openFailureActions?: (context: OpenFailureContext) => VNodeChild;
    }>, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly document: {
            readonly type: PropType<Uint8Array>;
            readonly default: undefined;
        };
        readonly mode: {
            readonly type: PropType<EditorMode>;
            readonly default: "edit";
        };
        readonly locale: {
            readonly type: PropType<LocaleCatalog>;
            readonly default: undefined;
        };
        readonly fontFamilies: {
            readonly type: PropType<readonly string[]>;
            readonly default: undefined;
        };
        readonly modules: {
            readonly type: PropType<readonly EditorModule[]>;
            readonly default: undefined;
        };
        readonly autoCorrect: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly readClipboardDrawing: {
            readonly type: PropType<ClipboardDrawingReader>;
            readonly default: undefined;
        };
        readonly author: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly popups: {
            readonly type: PropType<PptxEditorPopups>;
            readonly default: undefined;
        };
        readonly colorMode: {
            readonly type: PropType<ColorMode>;
            readonly default: undefined;
        };
        readonly fonts: {
            readonly type: PropType<EditorFontsOption>;
            readonly default: undefined;
        };
        readonly openFailure: {
            readonly type: PropType<boolean | PptxEditorOpenFailureProps>;
            readonly default: true;
        };
        readonly toolbar: {
            readonly type: PropType<boolean | ToolbarProps>;
            readonly default: true;
        };
        readonly menu: {
            readonly type: PropType<boolean | MenuProps>;
            readonly default: false;
        };
        readonly contextMenu: {
            readonly type: PropType<boolean | PptxEditorContextMenuProps>;
            readonly default: true;
        };
        readonly hyperlinkPopup: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly slideRail: {
            readonly type: PropType<boolean | SlideRailProps>;
            readonly default: true;
        };
        readonly notesPane: {
            readonly type: PropType<boolean | NotesPaneProps>;
            readonly default: true;
        };
    }>> & Readonly<{
        onReady?: ((_editor: PptxEditorInstance) => any) | undefined;
        onChange?: ((_editor: PptxEditorInstance) => any) | undefined;
        onFontError?: ((_error: EditorFontError) => any) | undefined;
    }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, {
        readonly document: Uint8Array<ArrayBufferLike>;
        readonly mode: EditorMode;
        readonly locale: LocaleCatalog;
        readonly menu: boolean | MenuProps;
        readonly contextMenu: boolean | PptxEditorContextMenuProps;
        readonly toolbar: boolean | ToolbarProps;
        readonly fonts: EditorFontsOption;
        readonly openFailure: boolean | PptxEditorOpenFailureProps;
        readonly fontFamilies: readonly string[];
        readonly modules: readonly EditorModule[];
        readonly autoCorrect: boolean;
        readonly readClipboardDrawing: ClipboardDrawingReader;
        readonly author: string;
        readonly popups: PptxEditorPopups;
        readonly colorMode: ColorMode;
        readonly hyperlinkPopup: boolean;
        readonly slideRail: boolean | SlideRailProps;
        readonly notesPane: boolean | NotesPaneProps;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly document: {
        readonly type: PropType<Uint8Array>;
        readonly default: undefined;
    };
    readonly mode: {
        readonly type: PropType<EditorMode>;
        readonly default: "edit";
    };
    readonly locale: {
        readonly type: PropType<LocaleCatalog>;
        readonly default: undefined;
    };
    readonly fontFamilies: {
        readonly type: PropType<readonly string[]>;
        readonly default: undefined;
    };
    readonly modules: {
        readonly type: PropType<readonly EditorModule[]>;
        readonly default: undefined;
    };
    readonly autoCorrect: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly readClipboardDrawing: {
        readonly type: PropType<ClipboardDrawingReader>;
        readonly default: undefined;
    };
    readonly author: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly popups: {
        readonly type: PropType<PptxEditorPopups>;
        readonly default: undefined;
    };
    readonly colorMode: {
        readonly type: PropType<ColorMode>;
        readonly default: undefined;
    };
    readonly fonts: {
        readonly type: PropType<EditorFontsOption>;
        readonly default: undefined;
    };
    readonly openFailure: {
        readonly type: PropType<boolean | PptxEditorOpenFailureProps>;
        readonly default: true;
    };
    readonly toolbar: {
        readonly type: PropType<boolean | ToolbarProps>;
        readonly default: true;
    };
    readonly menu: {
        readonly type: PropType<boolean | MenuProps>;
        readonly default: false;
    };
    readonly contextMenu: {
        readonly type: PropType<boolean | PptxEditorContextMenuProps>;
        readonly default: true;
    };
    readonly hyperlinkPopup: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly slideRail: {
        readonly type: PropType<boolean | SlideRailProps>;
        readonly default: true;
    };
    readonly notesPane: {
        readonly type: PropType<boolean | NotesPaneProps>;
        readonly default: true;
    };
}>> & Readonly<{
    onReady?: ((_editor: PptxEditorInstance) => any) | undefined;
    onChange?: ((_editor: PptxEditorInstance) => any) | undefined;
    onFontError?: ((_error: EditorFontError) => any) | undefined;
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    ready: (_editor: PptxEditorInstance) => true;
    change: (_editor: PptxEditorInstance) => true;
    fontError: (_error: EditorFontError) => true;
}, string, {
    readonly document: Uint8Array<ArrayBufferLike>;
    readonly mode: EditorMode;
    readonly locale: LocaleCatalog;
    readonly menu: boolean | MenuProps;
    readonly contextMenu: boolean | PptxEditorContextMenuProps;
    readonly toolbar: boolean | ToolbarProps;
    readonly fonts: EditorFontsOption;
    readonly openFailure: boolean | PptxEditorOpenFailureProps;
    readonly fontFamilies: readonly string[];
    readonly modules: readonly EditorModule[];
    readonly autoCorrect: boolean;
    readonly readClipboardDrawing: ClipboardDrawingReader;
    readonly author: string;
    readonly popups: PptxEditorPopups;
    readonly colorMode: ColorMode;
    readonly hyperlinkPopup: boolean;
    readonly slideRail: boolean | SlideRailProps;
    readonly notesPane: boolean | NotesPaneProps;
}, {}, string, SlotsType<{
    default?: () => VNodeChild;
    openFailureActions?: (context: OpenFailureContext) => VNodeChild;
}>, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Root: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly document: {
            readonly type: PropType<Uint8Array>;
            readonly default: undefined;
        };
        readonly mode: {
            readonly type: PropType<EditorMode>;
            readonly default: "edit";
        };
        readonly locale: {
            readonly type: PropType<LocaleCatalog>;
            readonly default: undefined;
        };
        readonly fonts: {
            readonly type: PropType<EditorFontsOption>;
            readonly default: undefined;
        };
        readonly fontFamilies: {
            readonly type: PropType<readonly string[]>;
            readonly default: undefined;
        };
        readonly modules: {
            readonly type: PropType<readonly EditorModule[]>;
            readonly default: undefined;
        };
        readonly autoCorrect: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly readClipboardDrawing: {
            readonly type: PropType<ClipboardDrawingReader>;
            readonly default: undefined;
        };
        readonly author: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly popups: {
            readonly type: PropType<PptxEditorPopups>;
            readonly default: undefined;
        };
        readonly colorMode: {
            readonly type: PropType<ColorMode>;
            readonly default: undefined;
        };
    }>, () => (vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>[] | undefined)[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
        ready: (_editor: PptxEditorInstance) => true;
        change: (_editor: PptxEditorInstance) => true;
        fontError: (_error: EditorFontError) => true;
    }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly document: {
            readonly type: PropType<Uint8Array>;
            readonly default: undefined;
        };
        readonly mode: {
            readonly type: PropType<EditorMode>;
            readonly default: "edit";
        };
        readonly locale: {
            readonly type: PropType<LocaleCatalog>;
            readonly default: undefined;
        };
        readonly fonts: {
            readonly type: PropType<EditorFontsOption>;
            readonly default: undefined;
        };
        readonly fontFamilies: {
            readonly type: PropType<readonly string[]>;
            readonly default: undefined;
        };
        readonly modules: {
            readonly type: PropType<readonly EditorModule[]>;
            readonly default: undefined;
        };
        readonly autoCorrect: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly readClipboardDrawing: {
            readonly type: PropType<ClipboardDrawingReader>;
            readonly default: undefined;
        };
        readonly author: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly popups: {
            readonly type: PropType<PptxEditorPopups>;
            readonly default: undefined;
        };
        readonly colorMode: {
            readonly type: PropType<ColorMode>;
            readonly default: undefined;
        };
    }>> & Readonly<{
        onReady?: ((_editor: PptxEditorInstance) => any) | undefined;
        onChange?: ((_editor: PptxEditorInstance) => any) | undefined;
        onFontError?: ((_error: EditorFontError) => any) | undefined;
    }>, {
        readonly document: Uint8Array<ArrayBufferLike>;
        readonly mode: EditorMode;
        readonly locale: LocaleCatalog;
        readonly fonts: EditorFontsOption;
        readonly fontFamilies: readonly string[];
        readonly modules: readonly EditorModule[];
        readonly autoCorrect: boolean;
        readonly readClipboardDrawing: ClipboardDrawingReader;
        readonly author: string;
        readonly popups: PptxEditorPopups;
        readonly colorMode: ColorMode;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Viewport: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly label: {
            readonly type: PropType<string | false>;
            readonly default: undefined;
        };
    }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly label: {
            readonly type: PropType<string | false>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly label: string | false;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Content: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>, () => VNodeChild[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Toolbar: PptxEditorToolbarNamespace;
    ToolbarControl: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly group: {
            readonly type: StringConstructor;
            readonly required: true;
        };
        readonly control: {
            readonly type: PropType<_pptx_editor_dev_core_editor.ChromeControl>;
            readonly required: true;
        };
    }>, () => vue.VNode, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly group: {
            readonly type: StringConstructor;
            readonly required: true;
        };
        readonly control: {
            readonly type: PropType<_pptx_editor_dev_core_editor.ChromeControl>;
            readonly required: true;
        };
    }>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    SlideRail: {
        new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
            readonly toggle: {
                readonly type: BooleanConstructor;
                readonly default: undefined;
            };
            readonly orientation: {
                readonly type: PropType<_pptx_editor_dev_core_editor.SlideRailOrientation>;
                readonly default: undefined;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly t: {
                readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
                readonly default: undefined;
            };
            readonly open: {
                readonly type: BooleanConstructor;
                readonly default: undefined;
            };
            readonly defaultOpen: {
                readonly type: BooleanConstructor;
                readonly default: undefined;
            };
            readonly paneWidth: {
                readonly type: NumberConstructor;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{
            "onUpdate:open"?: ((_open: boolean) => any) | undefined;
        }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
            'update:open': (_open: boolean) => true;
        }, vue.PublicProps, {
            readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
            readonly toggle: boolean;
            readonly orientation: _pptx_editor_dev_core_editor.SlideRailOrientation;
            readonly open: boolean;
            readonly defaultOpen: boolean;
            readonly paneWidth: number;
        }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<vue.ExtractPropTypes<{
            readonly toggle: {
                readonly type: BooleanConstructor;
                readonly default: undefined;
            };
            readonly orientation: {
                readonly type: PropType<_pptx_editor_dev_core_editor.SlideRailOrientation>;
                readonly default: undefined;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly t: {
                readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
                readonly default: undefined;
            };
            readonly open: {
                readonly type: BooleanConstructor;
                readonly default: undefined;
            };
            readonly defaultOpen: {
                readonly type: BooleanConstructor;
                readonly default: undefined;
            };
            readonly paneWidth: {
                readonly type: NumberConstructor;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{
            "onUpdate:open"?: ((_open: boolean) => any) | undefined;
        }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
            readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
            readonly toggle: boolean;
            readonly orientation: _pptx_editor_dev_core_editor.SlideRailOrientation;
            readonly open: boolean;
            readonly defaultOpen: boolean;
            readonly paneWidth: number;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
        readonly toggle: {
            readonly type: BooleanConstructor;
            readonly default: undefined;
        };
        readonly orientation: {
            readonly type: PropType<_pptx_editor_dev_core_editor.SlideRailOrientation>;
            readonly default: undefined;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
        readonly open: {
            readonly type: BooleanConstructor;
            readonly default: undefined;
        };
        readonly defaultOpen: {
            readonly type: BooleanConstructor;
            readonly default: undefined;
        };
        readonly paneWidth: {
            readonly type: NumberConstructor;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{
        "onUpdate:open"?: ((_open: boolean) => any) | undefined;
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
        'update:open': (_open: boolean) => true;
    }, string, {
        readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly className: string;
        readonly style: vue.CSSProperties;
        readonly preset: boolean;
        readonly toggle: boolean;
        readonly orientation: _pptx_editor_dev_core_editor.SlideRailOrientation;
        readonly open: boolean;
        readonly defaultOpen: boolean;
        readonly paneWidth: number;
    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
        AddSlide: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
            readonly hidden: boolean;
            readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>;
            readonly asChild: boolean;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
        ChooseLayout: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
            readonly hidden: boolean;
            readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>;
            readonly asChild: boolean;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
        Duplicate: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
            readonly hidden: boolean;
            readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>;
            readonly asChild: boolean;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
        MoveEarlier: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
            readonly hidden: boolean;
            readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>;
            readonly asChild: boolean;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
        MoveLater: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
            readonly hidden: boolean;
            readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>;
            readonly asChild: boolean;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
        Delete: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
            readonly hidden: boolean;
            readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>;
            readonly asChild: boolean;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
        Collapse: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
            readonly hidden: boolean;
            readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>;
            readonly asChild: boolean;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
        Expand: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
            readonly hidden: boolean;
            readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>;
            readonly asChild: boolean;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
        Action: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly label: {
                readonly type: StringConstructor;
                readonly required: true;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly active: {
                readonly type: PropType<boolean | undefined>;
                readonly default: undefined;
            };
            readonly disabled: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly disabledReason: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
            select: () => true;
        }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly label: {
                readonly type: StringConstructor;
                readonly required: true;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly active: {
                readonly type: PropType<boolean | undefined>;
                readonly default: undefined;
            };
            readonly disabled: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly disabledReason: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>> & Readonly<{
            onSelect?: (() => any) | undefined;
        }>, {
            readonly className: string;
            readonly disabled: boolean;
            readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>;
            readonly asChild: boolean;
            readonly active: boolean | undefined;
            readonly disabledReason: string;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    };
    SlideSorter: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    NotesPane: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly default: undefined;
        };
        readonly defaultOpen: {
            readonly type: BooleanConstructor;
            readonly default: undefined;
        };
        readonly showFormatButtons: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
        'update:open': (_open: boolean) => true;
    }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly default: undefined;
        };
        readonly defaultOpen: {
            readonly type: BooleanConstructor;
            readonly default: undefined;
        };
        readonly showFormatButtons: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{
        "onUpdate:open"?: ((_open: boolean) => any) | undefined;
    }>, {
        readonly className: string;
        readonly style: vue.CSSProperties;
        readonly open: boolean;
        readonly defaultOpen: boolean;
        readonly showFormatButtons: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    ZoomPill: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    SidePanel: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly paneWidth: {
            readonly type: NumberConstructor;
            readonly default: undefined;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
        readonly tab: {
            readonly type: PropType<_pptx_editor_dev_core_editor.SidePanelTab>;
            readonly default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
        tabChange: (_tab: _pptx_editor_dev_core_editor.SidePanelTab) => true;
        'update:tab': (_tab: _pptx_editor_dev_core_editor.SidePanelTab) => true;
    }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly paneWidth: {
            readonly type: NumberConstructor;
            readonly default: undefined;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
        readonly tab: {
            readonly type: PropType<_pptx_editor_dev_core_editor.SidePanelTab>;
            readonly default: undefined;
        };
    }>> & Readonly<{
        onTabChange?: ((_tab: "comments" | "diagram" | "format" | "chart" | "animations" | "selection") => any) | undefined;
        "onUpdate:tab"?: ((_tab: "comments" | "diagram" | "format" | "chart" | "animations" | "selection") => any) | undefined;
    }>, {
        readonly className: string;
        readonly style: vue.CSSProperties;
        readonly paneWidth: number;
        readonly onClose: () => void;
        readonly tab: "comments" | "diagram" | "format" | "chart" | "animations" | "selection";
    }, SlotsType<{
        comments?: (() => VNodeChild) | undefined;
        diagram?: (() => VNodeChild) | undefined;
        format?: (() => VNodeChild) | undefined;
        chart?: (() => VNodeChild) | undefined;
        animations?: (() => VNodeChild) | undefined;
        selection?: (() => VNodeChild) | undefined;
    }>, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    SelectionPane: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    FontNotice: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    EditNotice: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    OpenFailure: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
        readonly title: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly message: {
            readonly type: PropType<VNodeChild | ((failure: _pptx_editor_dev_core_contracts.DocumentOpenFailure) => VNodeChild)>;
            readonly default: undefined;
        };
        readonly showCode: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly showCopy: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly actions: {
            readonly type: PropType<(context: OpenFailureContext) => VNodeChild>;
            readonly default: undefined;
        };
        readonly closeLabel: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly showClose: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
        dismiss: (_failure: _pptx_editor_dev_core_contracts.DocumentOpenFailure) => true;
    }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
        readonly title: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly message: {
            readonly type: PropType<VNodeChild | ((failure: _pptx_editor_dev_core_contracts.DocumentOpenFailure) => VNodeChild)>;
            readonly default: undefined;
        };
        readonly showCode: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly showCopy: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly actions: {
            readonly type: PropType<(context: OpenFailureContext) => VNodeChild>;
            readonly default: undefined;
        };
        readonly closeLabel: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly showClose: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{
        onDismiss?: ((_failure: _pptx_editor_dev_core_contracts.DocumentOpenFailure) => any) | undefined;
    }>, {
        readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly title: string;
        readonly message: VNodeChild | ((failure: _pptx_editor_dev_core_contracts.DocumentOpenFailure) => VNodeChild);
        readonly showCode: boolean;
        readonly showCopy: boolean;
        readonly actions: (context: OpenFailureContext) => VNodeChild;
        readonly closeLabel: string;
        readonly showClose: boolean;
        readonly className: string;
        readonly style: vue.CSSProperties;
    }, SlotsType<{
        actions?: (context: OpenFailureContext) => VNodeChild;
        message?: (context: OpenFailureContext) => VNodeChild;
    }>, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Loading: {
        new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
            readonly when: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly overlay: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly when: boolean;
            readonly overlay: boolean;
        }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<vue.ExtractPropTypes<{
            readonly when: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly overlay: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly when: boolean;
            readonly overlay: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
        readonly when: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly overlay: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
        readonly className: string;
        readonly style: vue.CSSProperties;
        readonly when: boolean;
        readonly overlay: boolean;
    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
        Spinner: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    };
    PageSetupDialog: {
        new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly theme: {
                readonly type: PropType<"light" | "dark">;
                readonly default: "light";
            };
            readonly onThemeChange: {
                readonly type: PropType<(theme: "light" | "dark") => void>;
                readonly default: undefined;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
            readonly theme: "light" | "dark";
            readonly onThemeChange: (theme: "light" | "dark") => void;
        }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly theme: {
                readonly type: PropType<"light" | "dark">;
                readonly default: "light";
            };
            readonly onThemeChange: {
                readonly type: PropType<(theme: "light" | "dark") => void>;
                readonly default: undefined;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
            readonly theme: "light" | "dark";
            readonly onThemeChange: (theme: "light" | "dark") => void;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly theme: {
            readonly type: PropType<"light" | "dark">;
            readonly default: "light";
        };
        readonly onThemeChange: {
            readonly type: PropType<(theme: "light" | "dark") => void>;
            readonly default: undefined;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
        readonly className: string;
        readonly style: vue.CSSProperties;
        readonly preset: boolean;
        readonly theme: "light" | "dark";
        readonly onThemeChange: (theme: "light" | "dark") => void;
    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
        Header: vue.DefineComponent<DialogPartProps>;
        Title: vue.DefineComponent<DialogPartProps>;
        Body: vue.DefineComponent<DialogPartProps>;
        Footer: vue.DefineComponent<DialogPartProps>;
        Field: vue.DefineComponent<DialogPartProps & {
            readonly name: PageSetupDialogFieldName;
        }>;
        Error: vue.DefineComponent<DialogPartProps>;
        Apply: vue.DefineComponent<DialogPartProps>;
        Cancel: vue.DefineComponent<DialogPartProps>;
    };
    BackgroundDialog: {
        new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
        readonly className: string;
        readonly style: vue.CSSProperties;
        readonly preset: boolean;
    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
        Header: vue.DefineComponent<DialogPartProps>;
        Title: vue.DefineComponent<DialogPartProps>;
        Body: vue.DefineComponent<DialogPartProps>;
        Footer: vue.DefineComponent<DialogPartProps>;
        Field: vue.DefineComponent<DialogPartProps & {
            readonly name: BackgroundDialogFieldName;
        }>;
        Error: vue.DefineComponent<DialogPartProps>;
        Reset: vue.DefineComponent<DialogPartProps>;
        Apply: vue.DefineComponent<DialogPartProps>;
        Cancel: vue.DefineComponent<DialogPartProps>;
    };
    ImageAltTextDialog: {
        new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
        readonly className: string;
        readonly style: vue.CSSProperties;
        readonly preset: boolean;
    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
        Header: vue.DefineComponent<DialogPartProps>;
        Title: vue.DefineComponent<DialogPartProps>;
        Body: vue.DefineComponent<DialogPartProps>;
        Footer: vue.DefineComponent<DialogPartProps>;
        Field: vue.DefineComponent<DialogPartProps & {
            readonly name: ImageAltTextDialogFieldName;
        }>;
        Error: vue.DefineComponent<DialogPartProps>;
        Apply: vue.DefineComponent<DialogPartProps>;
        Cancel: vue.DefineComponent<DialogPartProps>;
    };
    ImagePropertiesDialog: {
        new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
        readonly className: string;
        readonly style: vue.CSSProperties;
        readonly preset: boolean;
    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
        Header: vue.DefineComponent<DialogPartProps>;
        Title: vue.DefineComponent<DialogPartProps>;
        Body: vue.DefineComponent<DialogPartProps>;
        Footer: vue.DefineComponent<DialogPartProps>;
        Field: vue.DefineComponent<DialogPartProps & {
            readonly name: ImagePropertiesDialogFieldName;
        }>;
        Error: vue.DefineComponent<DialogPartProps>;
        Apply: vue.DefineComponent<DialogPartProps>;
        Cancel: vue.DefineComponent<DialogPartProps>;
    };
    EquationDialog: {
        new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
        readonly className: string;
        readonly style: vue.CSSProperties;
        readonly preset: boolean;
    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
        Header: vue.DefineComponent<DialogPartProps>;
        Title: vue.DefineComponent<DialogPartProps>;
        Body: vue.DefineComponent<DialogPartProps>;
        Footer: vue.DefineComponent<DialogPartProps>;
        Field: vue.DefineComponent<DialogPartProps & {
            readonly name: EquationDialogFieldName;
        }>;
        Error: vue.DefineComponent<DialogPartProps>;
        Apply: vue.DefineComponent<DialogPartProps>;
        Cancel: vue.DefineComponent<DialogPartProps>;
    };
    ParagraphDialog: {
        new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
        readonly className: string;
        readonly style: vue.CSSProperties;
        readonly preset: boolean;
    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
        Header: vue.DefineComponent<DialogPartProps>;
        Title: vue.DefineComponent<DialogPartProps>;
        Body: vue.DefineComponent<DialogPartProps>;
        Footer: vue.DefineComponent<DialogPartProps>;
        Field: vue.DefineComponent<DialogPartProps & {
            readonly name: ParagraphDialogFieldName;
        }>;
        Error: vue.DefineComponent<DialogPartProps>;
        Apply: vue.DefineComponent<DialogPartProps>;
        Cancel: vue.DefineComponent<DialogPartProps>;
    };
    FontDialog: {
        new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
        readonly className: string;
        readonly style: vue.CSSProperties;
        readonly preset: boolean;
    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
        Header: vue.DefineComponent<DialogPartProps>;
        Title: vue.DefineComponent<DialogPartProps>;
        Body: vue.DefineComponent<DialogPartProps>;
        Footer: vue.DefineComponent<DialogPartProps>;
        Field: vue.DefineComponent<DialogPartProps & {
            readonly name: FontDialogFieldName;
        }>;
        Error: vue.DefineComponent<DialogPartProps>;
        Apply: vue.DefineComponent<DialogPartProps>;
        Cancel: vue.DefineComponent<DialogPartProps>;
    };
    BulletsAndNumberingDialog: {
        new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
        readonly className: string;
        readonly style: vue.CSSProperties;
        readonly preset: boolean;
    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
        Header: vue.DefineComponent<DialogPartProps>;
        Title: vue.DefineComponent<DialogPartProps>;
        Body: vue.DefineComponent<DialogPartProps>;
        Footer: vue.DefineComponent<DialogPartProps>;
        Field: vue.DefineComponent<DialogPartProps & {
            readonly name: BulletsAndNumberingDialogFieldName;
        }>;
        Error: vue.DefineComponent<DialogPartProps>;
        Apply: vue.DefineComponent<DialogPartProps>;
        Cancel: vue.DefineComponent<DialogPartProps>;
    };
    ColumnsDialog: {
        new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<vue.ExtractPropTypes<{
            readonly open: {
                readonly type: BooleanConstructor;
                readonly required: true;
            };
            readonly onClose: {
                readonly type: PropType<() => void>;
                readonly required: true;
            };
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly style: {
                readonly type: PropType<vue.CSSProperties>;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, {
            readonly className: string;
            readonly style: vue.CSSProperties;
            readonly preset: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
        readonly open: {
            readonly type: BooleanConstructor;
            readonly required: true;
        };
        readonly onClose: {
            readonly type: PropType<() => void>;
            readonly required: true;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<vue.CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
        readonly className: string;
        readonly style: vue.CSSProperties;
        readonly preset: boolean;
    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
        Header: vue.DefineComponent<DialogPartProps>;
        Title: vue.DefineComponent<DialogPartProps>;
        Body: vue.DefineComponent<DialogPartProps>;
        Footer: vue.DefineComponent<DialogPartProps>;
        Field: vue.DefineComponent<DialogPartProps & {
            readonly name: ColumnsDialogFieldName;
        }>;
        Error: vue.DefineComponent<DialogPartProps>;
        Apply: vue.DefineComponent<DialogPartProps>;
        Cancel: vue.DefineComponent<DialogPartProps>;
    };
    Slideshow: vue.DefineComponent<{}, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    FindBar: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
    }>, () => vue_jsx_runtime.JSX.Element | VNodeChild[] | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Menu: MenuNamespace;
    ContextMenu: ContextMenuNamespace;
    Ribbon: {
        new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly tab: {
                readonly type: PropType<_pptx_editor_dev_core_editor.RibbonTabId | (string & {})>;
                readonly default: undefined;
            };
            readonly defaultTab: {
                readonly type: PropType<_pptx_editor_dev_core_editor.RibbonTabId | (string & {})>;
                readonly default: "home";
            };
            readonly overflow: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>> & Readonly<{
            onTabChange?: ((_tab: string) => any) | undefined;
            "onUpdate:tab"?: ((_tab: string) => any) | undefined;
        }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
            'update:tab': (_tab: string) => true;
            tabChange: (_tab: string) => true;
        }, vue.PublicProps, {
            readonly className: string;
            readonly preset: boolean;
            readonly overflow: boolean;
            readonly tab: (string & {}) | _pptx_editor_dev_core_editor.RibbonTabId;
            readonly defaultTab: (string & {}) | _pptx_editor_dev_core_editor.RibbonTabId;
        }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<vue.ExtractPropTypes<{
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly tab: {
                readonly type: PropType<_pptx_editor_dev_core_editor.RibbonTabId | (string & {})>;
                readonly default: undefined;
            };
            readonly defaultTab: {
                readonly type: PropType<_pptx_editor_dev_core_editor.RibbonTabId | (string & {})>;
                readonly default: "home";
            };
            readonly overflow: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>> & Readonly<{
            onTabChange?: ((_tab: string) => any) | undefined;
            "onUpdate:tab"?: ((_tab: string) => any) | undefined;
        }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>, {}, {}, {}, {
            readonly className: string;
            readonly preset: boolean;
            readonly overflow: boolean;
            readonly tab: (string & {}) | _pptx_editor_dev_core_editor.RibbonTabId;
            readonly defaultTab: (string & {}) | _pptx_editor_dev_core_editor.RibbonTabId;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly tab: {
            readonly type: PropType<_pptx_editor_dev_core_editor.RibbonTabId | (string & {})>;
            readonly default: undefined;
        };
        readonly defaultTab: {
            readonly type: PropType<_pptx_editor_dev_core_editor.RibbonTabId | (string & {})>;
            readonly default: "home";
        };
        readonly overflow: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>> & Readonly<{
        onTabChange?: ((_tab: string) => any) | undefined;
        "onUpdate:tab"?: ((_tab: string) => any) | undefined;
    }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
        'update:tab': (_tab: string) => true;
        tabChange: (_tab: string) => true;
    }, string, {
        readonly className: string;
        readonly preset: boolean;
        readonly overflow: boolean;
        readonly tab: (string & {}) | _pptx_editor_dev_core_editor.RibbonTabId;
        readonly defaultTab: (string & {}) | _pptx_editor_dev_core_editor.RibbonTabId;
    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
        Tab: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly id: {
                readonly type: PropType<_pptx_editor_dev_core_editor.RibbonTabId | (string & {})>;
                readonly required: true;
            };
            readonly label: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly labelKey: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly after: {
                readonly type: PropType<_pptx_editor_dev_core_editor.RibbonTabId | (string & {})>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly id: {
                readonly type: PropType<_pptx_editor_dev_core_editor.RibbonTabId | (string & {})>;
                readonly required: true;
            };
            readonly label: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly labelKey: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly after: {
                readonly type: PropType<_pptx_editor_dev_core_editor.RibbonTabId | (string & {})>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
            readonly label: string;
            readonly hidden: boolean;
            readonly after: (string & {}) | _pptx_editor_dev_core_editor.RibbonTabId;
            readonly labelKey: string;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    };
    StatusBar: {
        new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly t: {
                readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
            readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly className: string;
            readonly preset: boolean;
        }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<vue.ExtractPropTypes<{
            readonly preset: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly t: {
                readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>, {}, {}, {}, {
            readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly className: string;
            readonly preset: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
        readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly className: string;
        readonly preset: boolean;
    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
        SlideNumber: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
            readonly hidden: boolean;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
        Notes: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
            readonly hidden: boolean;
            readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>;
            readonly asChild: boolean;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
        Views: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
            readonly hidden: boolean;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
        Zoom: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly hidden: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
        }>> & Readonly<{}>, {
            readonly className: string;
            readonly hidden: boolean;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
        Action: vue.DefineComponent<vue.ExtractPropTypes<{
            readonly label: {
                readonly type: StringConstructor;
                readonly required: true;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly active: {
                readonly type: PropType<boolean | undefined>;
                readonly default: undefined;
            };
            readonly disabled: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly disabledReason: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
            select: () => true;
        }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
            readonly label: {
                readonly type: StringConstructor;
                readonly required: true;
            };
            readonly icon: {
                readonly type: PropType<vue.VNode>;
                readonly default: undefined;
            };
            readonly className: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly active: {
                readonly type: PropType<boolean | undefined>;
                readonly default: undefined;
            };
            readonly disabled: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly disabledReason: {
                readonly type: StringConstructor;
                readonly default: undefined;
            };
            readonly asChild: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
        }>> & Readonly<{
            onSelect?: (() => any) | undefined;
        }>, {
            readonly className: string;
            readonly disabled: boolean;
            readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>;
            readonly asChild: boolean;
            readonly active: boolean | undefined;
            readonly disabledReason: string;
        }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    };
}

`PptxEditorContent`constSource ↗

The slide canvas: attaches the engine surface while it is mounted. Right-click, Shift+F10, and the Menu key open its context menu.

PptxEditorContent: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => vue.VNodeChild[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditorContextMenu`constSource ↗

The slide canvas's context menu (PptxEditorContextMenu), with DOCX Editor's parts (Slot, Item, Group, Separator, Submenu). Place it in the root or the viewport, or render it in popups.contextMenu.

PptxEditorContextMenu: ContextMenuNamespace

```ts
const popups: PptxEditorPopups = {
  contextMenu: (props) =>
    h(PptxEditorContextMenu, props, () => [
      h(PptxEditorContextMenu.Slot, { slotId: 'format.painter', hidden: true }),
      h(PptxEditorContextMenu.Item, { label: 'Ask legal', icon: 'info', onSelect: askLegal }),
    ]),
};
```

`PptxEditorEditNotice`constSource ↗

Why the last edit was refused, or what the last Delete removed with an Undo action; the twin of React's PptxEditor.EditNotice. Renders nothing while edits apply, and nothing for a command that had nothing to do (EditorRejection.noop). A host class goes on the notice.

PptxEditorEditNotice: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly t: {
        readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly t: {
        readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
    readonly className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditorFindBar`constSource ↗

The find and replace bar, the twin of React's PptxEditor.FindBar. Render one inside the editor's viewport, over the canvas. A host class goes on the bar.

PptxEditorFindBar: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly t: {
        readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | vue.VNodeChild[] | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly t: {
        readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
    readonly className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditorFontNotice`constSource ↗

The substitution notice, the twin of React's PptxEditor.FontNotice. Renders nothing when every font is available. A host class goes on the notice.

PptxEditorFontNotice: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly t: {
        readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly t: {
        readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
    readonly className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditorHyperLink`constSource ↗

PptxEditorHyperLink: the link popup with named parts, the twin of React's.

PptxEditorHyperLink: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>[] | vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly className: string;
        readonly preset: boolean;
        readonly hidden: boolean;
        readonly asChild: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>[] | vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        readonly className: string;
        readonly preset: boolean;
        readonly hidden: boolean;
        readonly asChild: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[] | vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly className: string;
    readonly preset: boolean;
    readonly hidden: boolean;
    readonly asChild: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Url: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Copy: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Edit: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Unlink: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Fields: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Error: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Apply: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Cancel: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
}

`pptxEditorKey`constSource ↗

The editor instance published by PptxEditorRoot.

pptxEditorKey: InjectionKey<ShallowRef<PptxEditorInstance | null>>

`PptxEditorLoading`constSource ↗

Shows a slide-shaped sheet with a spinner while the editor has no deck, and while a deck opens; renders nothing once the deck is ready. A parse failure clears it. The indicator slot replaces only the spinner; the default slot replaces the whole screen. The packaged spinner is on it as PptxEditorLoading.Spinner, as React's Loading.Spinner.

vue <PptxEditorLoading overlay> <template #indicator><MySpinner label="Opening presentation" /></template> </PptxEditorLoading>

PptxEditorLoading: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly when: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly overlay: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly when: boolean;
        readonly overlay: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly when: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly overlay: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, {
        readonly className: string;
        readonly style: CSSProperties;
        readonly when: boolean;
        readonly overlay: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly when: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly overlay: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>> & Readonly<{}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly className: string;
    readonly style: CSSProperties;
    readonly when: boolean;
    readonly overlay: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Spinner: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
}

`PptxEditorLoadingSpinner`constSource ↗

The packaged spinner on its own, to compose into the default slot. It is decorative (aria-hidden), so give the surrounding screen its own text.

PptxEditorLoadingSpinner: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditorMenu`constSource ↗

The menu bar (PptxEditorMenu): File, Edit, View, Insert, Format, Arrange, and Slide Show, with DOCX Editor's parts (Entry, Item, Row, Group, Separator, Submenu) and one named part per menu (PptxEditorMenu.File, …).

PptxEditorMenu: MenuNamespace

```vue
<PptxEditorMenu>
  <PptxEditorMenu.File>
    <PptxEditorMenu.Row label="Open…" icon="folder_open" @select="openFile" />
  </PptxEditorMenu.File>
  <PptxEditorMenu.Edit>
    <PptxEditorMenu.Item slot-id="more.delete" hidden />
  </PptxEditorMenu.Edit>
  <PptxEditorMenu.Arrange hidden />
</PptxEditorMenu>
```

`PptxEditorNotesPane`constSource ↗

Collapsible speaker notes for the current slide, the twin of React's PptxEditor.NotesPane. The text shown is the document's; only the text typed since the field took focus is held here, bound to the slide it was typed on. It is written to that slide (wherever the slide is now) when the field loses focus, when the pointer goes down anywhere else, when the current slide changes, and before a format or an undo. Emits update:open.

PptxEditorNotesPane: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
    readonly defaultOpen: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
    readonly showFormatButtons: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    'update:open': (_open: boolean) => true;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly open: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
    readonly defaultOpen: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
    readonly showFormatButtons: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>> & Readonly<{
    "onUpdate:open"?: ((_open: boolean) => any) | undefined;
}>, {
    readonly className: string;
    readonly style: CSSProperties;
    readonly open: boolean;
    readonly defaultOpen: boolean;
    readonly showFormatButtons: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditorOpenFailure`constSource ↗

A notice that explains why a file did not open, the twin of React's PptxEditor.OpenFailure. It shows nothing until the editor refuses a file, and shows again for each later refusal. PptxEditor renders it by default. The actions slot (or prop) adds buttons before **Close**, and the message slot (or prop) replaces the message. It emits dismiss after the person closes it:

vue <PptxEditorOpenFailure> <template #actions="{ failure }"> <a class="pptx-open-failure__action" :href="/support?code=${failure.code}">Get help</a> </template> </PptxEditorOpenFailure>

PptxEditorOpenFailure: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly t: {
        readonly type: () => ChromeTranslate;
        readonly default: undefined;
    };
    readonly title: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly message: {
        readonly type: PropType<VNodeChild | ((failure: DocumentOpenFailure) => VNodeChild)>;
        readonly default: undefined;
    };
    readonly showCode: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly showCopy: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly actions: {
        readonly type: PropType<(context: OpenFailureContext) => VNodeChild>;
        readonly default: undefined;
    };
    readonly closeLabel: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly showClose: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    dismiss: (_failure: DocumentOpenFailure) => true;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly t: {
        readonly type: () => ChromeTranslate;
        readonly default: undefined;
    };
    readonly title: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly message: {
        readonly type: PropType<VNodeChild | ((failure: DocumentOpenFailure) => VNodeChild)>;
        readonly default: undefined;
    };
    readonly showCode: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly showCopy: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly actions: {
        readonly type: PropType<(context: OpenFailureContext) => VNodeChild>;
        readonly default: undefined;
    };
    readonly closeLabel: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly showClose: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>> & Readonly<{
    onDismiss?: ((_failure: DocumentOpenFailure) => any) | undefined;
}>, {
    readonly t: ChromeTranslate;
    readonly title: string;
    readonly message: VNodeChild | ((failure: DocumentOpenFailure) => VNodeChild);
    readonly showCode: boolean;
    readonly showCopy: boolean;
    readonly actions: (context: OpenFailureContext) => VNodeChild;
    readonly closeLabel: string;
    readonly showClose: boolean;
    readonly className: string;
    readonly style: CSSProperties;
}, SlotsType<{
    actions?: (context: OpenFailureContext) => VNodeChild;
    message?: (context: OpenFailureContext) => VNodeChild;
}>, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditorRibbon`constSource ↗

The ribbon: the Quick Access Toolbar, the tab names, and the selected tab's groups, with contextual tabs while the selection needs them, as React's PptxEditor.Ribbon. Emits update:tab (for v-model:tab) and tabChange. The tabs are attached as PptxEditorRibbon.Tab.

PptxEditorRibbon: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly tab: {
            readonly type: PropType<RibbonTabId | (string & {})>;
            readonly default: undefined;
        };
        readonly defaultTab: {
            readonly type: PropType<RibbonTabId | (string & {})>;
            readonly default: "home";
        };
        readonly overflow: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>> & Readonly<{
        onTabChange?: ((_tab: string) => any) | undefined;
        "onUpdate:tab"?: ((_tab: string) => any) | undefined;
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
        'update:tab': (_tab: string) => true;
        tabChange: (_tab: string) => true;
    }, vue.PublicProps, {
        readonly className: string;
        readonly preset: boolean;
        readonly overflow: boolean;
        readonly tab: (string & {}) | RibbonTabId;
        readonly defaultTab: (string & {}) | RibbonTabId;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly tab: {
            readonly type: PropType<RibbonTabId | (string & {})>;
            readonly default: undefined;
        };
        readonly defaultTab: {
            readonly type: PropType<RibbonTabId | (string & {})>;
            readonly default: "home";
        };
        readonly overflow: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>> & Readonly<{
        onTabChange?: ((_tab: string) => any) | undefined;
        "onUpdate:tab"?: ((_tab: string) => any) | undefined;
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, {
        readonly className: string;
        readonly preset: boolean;
        readonly overflow: boolean;
        readonly tab: (string & {}) | RibbonTabId;
        readonly defaultTab: (string & {}) | RibbonTabId;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly tab: {
        readonly type: PropType<RibbonTabId | (string & {})>;
        readonly default: undefined;
    };
    readonly defaultTab: {
        readonly type: PropType<RibbonTabId | (string & {})>;
        readonly default: "home";
    };
    readonly overflow: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{
    onTabChange?: ((_tab: string) => any) | undefined;
    "onUpdate:tab"?: ((_tab: string) => any) | undefined;
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    'update:tab': (_tab: string) => true;
    tabChange: (_tab: string) => true;
}, string, {
    readonly className: string;
    readonly preset: boolean;
    readonly overflow: boolean;
    readonly tab: (string & {}) | RibbonTabId;
    readonly defaultTab: (string & {}) | RibbonTabId;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    Tab: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly id: {
            readonly type: PropType<RibbonTabId | (string & {})>;
            readonly required: true;
        };
        readonly label: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly labelKey: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly after: {
            readonly type: PropType<RibbonTabId | (string & {})>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly id: {
            readonly type: PropType<RibbonTabId | (string & {})>;
            readonly required: true;
        };
        readonly label: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly labelKey: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly after: {
            readonly type: PropType<RibbonTabId | (string & {})>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly label: string;
        readonly hidden: boolean;
        readonly after: (string & {}) | RibbonTabId;
        readonly labelKey: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
}

`PptxEditorRoot`constSource ↗

Owns the editor instance, as React's PptxEditor.Root. Only document identity reloads the document; mode and locale apply without a reload. Emits ready once per instance and change after every change of editor state.

PptxEditorRoot: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly document: {
        readonly type: PropType<Uint8Array>;
        readonly default: undefined;
    };
    readonly mode: {
        readonly type: PropType<EditorMode>;
        readonly default: "edit";
    };
    readonly locale: {
        readonly type: PropType<LocaleCatalog>;
        readonly default: undefined;
    };
    readonly fonts: {
        readonly type: PropType<EditorFontsOption>;
        readonly default: undefined;
    };
    readonly fontFamilies: {
        readonly type: PropType<readonly string[]>;
        readonly default: undefined;
    };
    readonly modules: {
        readonly type: PropType<readonly EditorModule[]>;
        readonly default: undefined;
    };
    readonly autoCorrect: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly readClipboardDrawing: {
        readonly type: PropType<ClipboardDrawingReader>;
        readonly default: undefined;
    };
    readonly author: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly popups: {
        readonly type: PropType<PptxEditorPopups>;
        readonly default: undefined;
    };
    readonly colorMode: {
        readonly type: PropType<ColorMode>;
        readonly default: undefined;
    };
}>, () => (vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[] | undefined)[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    ready: (_editor: PptxEditorInstance) => true;
    change: (_editor: PptxEditorInstance) => true;
    fontError: (_error: EditorFontError) => true;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly document: {
        readonly type: PropType<Uint8Array>;
        readonly default: undefined;
    };
    readonly mode: {
        readonly type: PropType<EditorMode>;
        readonly default: "edit";
    };
    readonly locale: {
        readonly type: PropType<LocaleCatalog>;
        readonly default: undefined;
    };
    readonly fonts: {
        readonly type: PropType<EditorFontsOption>;
        readonly default: undefined;
    };
    readonly fontFamilies: {
        readonly type: PropType<readonly string[]>;
        readonly default: undefined;
    };
    readonly modules: {
        readonly type: PropType<readonly EditorModule[]>;
        readonly default: undefined;
    };
    readonly autoCorrect: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly readClipboardDrawing: {
        readonly type: PropType<ClipboardDrawingReader>;
        readonly default: undefined;
    };
    readonly author: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly popups: {
        readonly type: PropType<PptxEditorPopups>;
        readonly default: undefined;
    };
    readonly colorMode: {
        readonly type: PropType<ColorMode>;
        readonly default: undefined;
    };
}>> & Readonly<{
    onReady?: ((_editor: PptxEditorInstance) => any) | undefined;
    onChange?: ((_editor: PptxEditorInstance) => any) | undefined;
    onFontError?: ((_error: EditorFontError) => any) | undefined;
}>, {
    readonly document: Uint8Array<ArrayBufferLike>;
    readonly mode: EditorMode;
    readonly locale: LocaleCatalog;
    readonly fonts: EditorFontsOption;
    readonly fontFamilies: readonly string[];
    readonly modules: readonly EditorModule[];
    readonly autoCorrect: boolean;
    readonly readClipboardDrawing: ClipboardDrawingReader;
    readonly author: string;
    readonly popups: PptxEditorPopups;
    readonly colorMode: ColorMode;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditorSelectionPane`constSource ↗

The selection pane: select, show or hide, rename, and reorder the elements of the current slide, the twin of React's PptxEditor.SelectionPane. Render it inside the editor root, or open the side panel's **Selection** tab.

PptxEditorSelectionPane: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditorSidePanel`constSource ↗

The side panel: Format · Chart Data · Diagram · Selection · Animations · Comments, the twin of React's PptxEditor.SidePanel. The host shows or hides the panel by rendering it.

PptxEditorSidePanel: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly paneWidth: {
        readonly type: NumberConstructor;
        readonly default: undefined;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
    readonly tab: {
        readonly type: PropType<SidePanelTab>;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    tabChange: (_tab: SidePanelTab) => true;
    'update:tab': (_tab: SidePanelTab) => true;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly paneWidth: {
        readonly type: NumberConstructor;
        readonly default: undefined;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
    readonly tab: {
        readonly type: PropType<SidePanelTab>;
        readonly default: undefined;
    };
}>> & Readonly<{
    onTabChange?: ((_tab: "comments" | "diagram" | "format" | "chart" | "animations" | "selection") => any) | undefined;
    "onUpdate:tab"?: ((_tab: "comments" | "diagram" | "format" | "chart" | "animations" | "selection") => any) | undefined;
}>, {
    readonly className: string;
    readonly style: CSSProperties;
    readonly paneWidth: number;
    readonly onClose: () => void;
    readonly tab: "comments" | "diagram" | "format" | "chart" | "animations" | "selection";
}, SlotsType<{
    comments?: (() => VNodeChild) | undefined;
    diagram?: (() => VNodeChild) | undefined;
    format?: (() => VNodeChild) | undefined;
    chart?: (() => VNodeChild) | undefined;
    animations?: (() => VNodeChild) | undefined;
    selection?: (() => VNodeChild) | undefined;
}>, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditorSlideRail`constSource ↗

The slide rail with its action parts, as React's PptxEditor.SlideRail: a named part child replaces its button, hidden removes it, other children go after Delete, and preset: false renders only the default slot. Action is ToolbarAction.

PptxEditorSlideRail: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly toggle: {
            readonly type: BooleanConstructor;
            readonly default: undefined;
        };
        readonly orientation: {
            readonly type: PropType<SlideRailOrientation>;
            readonly default: undefined;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
        readonly open: {
            readonly type: BooleanConstructor;
            readonly default: undefined;
        };
        readonly defaultOpen: {
            readonly type: BooleanConstructor;
            readonly default: undefined;
        };
        readonly paneWidth: {
            readonly type: NumberConstructor;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{
        "onUpdate:open"?: ((_open: boolean) => any) | undefined;
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
        'update:open': (_open: boolean) => true;
    }, vue.PublicProps, {
        readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
        readonly toggle: boolean;
        readonly orientation: SlideRailOrientation;
        readonly open: boolean;
        readonly defaultOpen: boolean;
        readonly paneWidth: number;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly toggle: {
            readonly type: BooleanConstructor;
            readonly default: undefined;
        };
        readonly orientation: {
            readonly type: PropType<SlideRailOrientation>;
            readonly default: undefined;
        };
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
        readonly open: {
            readonly type: BooleanConstructor;
            readonly default: undefined;
        };
        readonly defaultOpen: {
            readonly type: BooleanConstructor;
            readonly default: undefined;
        };
        readonly paneWidth: {
            readonly type: NumberConstructor;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly style: {
            readonly type: PropType<CSSProperties>;
            readonly default: undefined;
        };
    }>> & Readonly<{
        "onUpdate:open"?: ((_open: boolean) => any) | undefined;
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, {
        readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly className: string;
        readonly style: CSSProperties;
        readonly preset: boolean;
        readonly toggle: boolean;
        readonly orientation: SlideRailOrientation;
        readonly open: boolean;
        readonly defaultOpen: boolean;
        readonly paneWidth: number;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly toggle: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
    readonly orientation: {
        readonly type: PropType<SlideRailOrientation>;
        readonly default: undefined;
    };
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly t: {
        readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly default: undefined;
    };
    readonly open: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
    readonly defaultOpen: {
        readonly type: BooleanConstructor;
        readonly default: undefined;
    };
    readonly paneWidth: {
        readonly type: NumberConstructor;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly style: {
        readonly type: PropType<CSSProperties>;
        readonly default: undefined;
    };
}>> & Readonly<{
    "onUpdate:open"?: ((_open: boolean) => any) | undefined;
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    'update:open': (_open: boolean) => true;
}, string, {
    readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
    readonly className: string;
    readonly style: CSSProperties;
    readonly preset: boolean;
    readonly toggle: boolean;
    readonly orientation: SlideRailOrientation;
    readonly open: boolean;
    readonly defaultOpen: boolean;
    readonly paneWidth: number;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    AddSlide: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    ChooseLayout: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Duplicate: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    MoveEarlier: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    MoveLater: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Delete: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Collapse: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Expand: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Action: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly label: {
            readonly type: StringConstructor;
            readonly required: true;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly active: {
            readonly type: PropType<boolean | undefined>;
            readonly default: undefined;
        };
        readonly disabled: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly disabledReason: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
        select: () => true;
    }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly label: {
            readonly type: StringConstructor;
            readonly required: true;
        };
        readonly icon: {
            readonly type: PropType<vue.VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly active: {
            readonly type: PropType<boolean | undefined>;
            readonly default: undefined;
        };
        readonly disabled: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly disabledReason: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{
        onSelect?: (() => any) | undefined;
    }>, {
        readonly className: string;
        readonly disabled: boolean;
        readonly icon: vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        readonly asChild: boolean;
        readonly active: boolean | undefined;
        readonly disabledReason: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
}

`PptxEditorSlideshow`constSource ↗

The slide show of the editor in PptxEditorRoot, the twin of React's PptxEditor.Slideshow. Mount it once inside the viewport. It shows nothing until a show starts: useSlideshow().start(...), or the keys F5 (from the start) and Shift+F5 or Ctrl/Cmd+Enter (from the current slide).

PptxEditorSlideshow: vue.DefineComponent<{}, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditorSlideSorter`constSource ↗

The slide sorter, the twin of React's PptxEditor.SlideSorter. Put it where the slide and the rail go in the Normal view, while snapshot().presentationView is slideSorter. When the view becomes slideSorter and no sorter of the editor is mounted, a development warning says so.

PptxEditorSlideSorter: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditorStatusBar`constSource ↗

The status bar: "Slide x of y", the Notes button, the view buttons, and zoom, as React's PptxEditor.StatusBar. A named part child replaces its part in place; other children follow the Notes button. The parts are attached as PptxEditorStatusBar.SlideNumber, .Notes, .Views, and .Zoom.

PptxEditorStatusBar: {
    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<Readonly<vue.ExtractPropTypes<{
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.PublicProps, {
        readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly className: string;
        readonly preset: boolean;
    }, true, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<vue.ExtractPropTypes<{
        readonly preset: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly t: {
            readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, {
        readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly className: string;
        readonly preset: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly preset: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly t: {
        readonly type: () => _pptx_editor_dev_core_editor.ChromeTranslate;
        readonly default: undefined;
    };
}>> & Readonly<{}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly t: _pptx_editor_dev_core_editor.ChromeTranslate;
    readonly className: string;
    readonly preset: boolean;
}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
    SlideNumber: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Notes: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly icon: {
            readonly type: PropType<VNode>;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly icon: {
            readonly type: PropType<VNode>;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
        readonly icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        readonly asChild: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Views: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Zoom: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly hidden: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
    }>> & Readonly<{}>, {
        readonly className: string;
        readonly hidden: boolean;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
    Action: vue.DefineComponent<vue.ExtractPropTypes<{
        readonly label: {
            readonly type: StringConstructor;
            readonly required: true;
        };
        readonly icon: {
            readonly type: PropType<VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly active: {
            readonly type: PropType<boolean | undefined>;
            readonly default: undefined;
        };
        readonly disabled: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly disabledReason: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>, () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
        select: () => true;
    }, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
        readonly label: {
            readonly type: StringConstructor;
            readonly required: true;
        };
        readonly icon: {
            readonly type: PropType<VNode>;
            readonly default: undefined;
        };
        readonly className: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly active: {
            readonly type: PropType<boolean | undefined>;
            readonly default: undefined;
        };
        readonly disabled: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly disabledReason: {
            readonly type: StringConstructor;
            readonly default: undefined;
        };
        readonly asChild: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
    }>> & Readonly<{
        onSelect?: (() => any) | undefined;
    }>, {
        readonly className: string;
        readonly disabled: boolean;
        readonly icon: VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>;
        readonly asChild: boolean;
        readonly active: boolean | undefined;
        readonly disabledReason: string;
    }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
}

`PptxEditorToolbar`constSource ↗

The toolbar, with its parts as statics, as React's PptxEditor.Toolbar: Slot, Group, Action, Separator, and the named parts (PptxEditorToolbar.Bold, …).

PptxEditorToolbar: PptxEditorToolbarNamespace

`PptxEditorViewport`constSource ↗

The editor's scroll and styling scope: carries the .pptx-editor class, and dark with it when the root's colorMode resolves to dark. It is a named landmark region ("Presentation editor"), so a screen reader user can go to the editor from anywhere on the page.

PptxEditorViewport: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: PropType<string | false>;
        readonly default: undefined;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly label: {
        readonly type: PropType<string | false>;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string | false;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`PptxEditorZoomPill`constSource ↗

The zoom pill (– 100% ▾ +), the twin of React's PptxEditor.ZoomPill.

PptxEditorZoomPill: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`pptxSlideshowKey`constSource ↗

The slide show published by PptxEditorRoot, the twin of React's SlideshowContext.

pptxSlideshowKey: InjectionKey<UseSlideshowReturn>

`pptxTranslationKey`constSource ↗

The translator published by PptxEditorRoot from its locale prop.

pptxTranslationKey: InjectionKey<ShallowRef<Translate>>

`RailContextMenu`constSource ↗

The slide rail's context menu: new, duplicate, delete, and move slides, background, and present from here. Rows act on every selected slide.

RailContextMenu: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly menu: {
        readonly type: PropType<RailMenuState>;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly onSectionAdded: {
        readonly type: PropType<(sectionId: string) => void>;
        readonly default: undefined;
    };
    readonly onBackground: {
        readonly type: PropType<() => void>;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly menu: {
        readonly type: PropType<RailMenuState>;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly onSectionAdded: {
        readonly type: PropType<(sectionId: string) => void>;
        readonly default: undefined;
    };
    readonly onBackground: {
        readonly type: PropType<() => void>;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly onSectionAdded: (sectionId: string) => void;
    readonly onBackground: () => void;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`RibbonTab`constSource ↗

One tab of the ribbon: a description PptxEditorRibbon reads. Its slot is toolbar children.

RibbonTab: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly id: {
        readonly type: PropType<RibbonTabId | (string & {})>;
        readonly required: true;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly labelKey: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly after: {
        readonly type: PropType<RibbonTabId | (string & {})>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly id: {
        readonly type: PropType<RibbonTabId | (string & {})>;
        readonly required: true;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly labelKey: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly after: {
        readonly type: PropType<RibbonTabId | (string & {})>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly hidden: boolean;
    readonly after: (string & {}) | RibbonTabId;
    readonly labelKey: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`SectionContextMenu`constSource ↗

The section menu: Rename, Remove, Remove with slides, Remove all, Move up and down, Collapse and Expand all. Every row asks the engine whether it can run.

SectionContextMenu: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly section: {
        readonly type: PropType<SlideSection>;
        readonly required: true;
    };
    readonly menu: {
        readonly type: PropType<SectionMenuState>;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly onRename: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly onRemoved: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly section: {
        readonly type: PropType<SlideSection>;
        readonly required: true;
    };
    readonly menu: {
        readonly type: PropType<SectionMenuState>;
        readonly required: true;
    };
    readonly onClose: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly onRename: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
    readonly onRemoved: {
        readonly type: PropType<() => void>;
        readonly required: true;
    };
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`ShapeGalleryControl`constSource ↗

The insert-shape gallery: every category, every preset as its own preview.

ShapeGalleryControl: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly slot: {
        readonly type: PropType<ChromeSlotId>;
        readonly required: true;
    };
    readonly control: {
        readonly type: PropType<ChromeControl>;
        readonly required: true;
    };
}>, () => (vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null)[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly slot: {
        readonly type: PropType<ChromeSlotId>;
        readonly required: true;
    };
    readonly control: {
        readonly type: PropType<ChromeControl>;
        readonly required: true;
    };
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`ShapeGrid`constSource ↗

One gallery category's presets as a grid of previews drawn from their spec geometry. Each preview is a menuitem; the arrow keys move by grid rows (data-columns). A pick calls onPick with the preset.

ShapeGrid: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly presets: {
        readonly type: PropType<readonly string[]>;
        readonly required: true;
    };
    readonly onPick: {
        readonly type: PropType<(preset: string) => void>;
        readonly required: true;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly presets: {
        readonly type: PropType<readonly string[]>;
        readonly required: true;
    };
    readonly onPick: {
        readonly type: PropType<(preset: string) => void>;
        readonly required: true;
    };
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`ShapeIcon`constSource ↗

A preset's preview, drawn from its spec geometry.

ShapeIcon: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly preset: {
        readonly type: StringConstructor;
        readonly required: true;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly preset: {
        readonly type: StringConstructor;
        readonly required: true;
    };
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`ShapeStyleGallery`constSource ↗

The Quick Styles gallery: six theme style rows of seven colors, drawn with the current slide's theme. Put it in a popover or a menu. A pick calls onPick with the cell; className (or a host class) goes on the gallery.

ShapeStyleGallery: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly value: {
        readonly type: PropType<ShapeStyleChoice | ShapeStyleValue | null>;
        readonly default: undefined;
    };
    readonly onPick: {
        readonly type: PropType<(cell: ShapeStyleChoice) => void>;
        readonly required: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => vue_jsx_runtime.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly value: {
        readonly type: PropType<ShapeStyleChoice | ShapeStyleValue | null>;
        readonly default: undefined;
    };
    readonly onPick: {
        readonly type: PropType<(cell: ShapeStyleChoice) => void>;
        readonly required: true;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly value: ShapeStyleChoice | "coloredOutline.dk1" | "coloredOutline.accent1" | "coloredOutline.accent2" | "coloredOutline.accent3" | "coloredOutline.accent4" | "coloredOutline.accent5" | "coloredOutline.accent6" | "coloredFill.dk1" | "coloredFill.accent1" | "coloredFill.accent2" | "coloredFill.accent3" | "coloredFill.accent4" | "coloredFill.accent5" | "coloredFill.accent6" | "lightOutline.dk1" | "lightOutline.accent1" | "lightOutline.accent2" | "lightOutline.accent3" | "lightOutline.accent4" | "lightOutline.accent5" | "lightOutline.accent6" | "subtleEffect.dk1" | "subtleEffect.accent1" | "subtleEffect.accent2" | "subtleEffect.accent3" | "subtleEffect.accent4" | "subtleEffect.accent5" | "subtleEffect.accent6" | "moderateEffect.dk1" | "moderateEffect.accent1" | "moderateEffect.accent2" | "moderateEffect.accent3" | "moderateEffect.accent4" | "moderateEffect.accent5" | "moderateEffect.accent6" | "intenseEffect.dk1" | "intenseEffect.accent1" | "intenseEffect.accent2" | "intenseEffect.accent3" | "intenseEffect.accent4" | "intenseEffect.accent5" | "intenseEffect.accent6" | null;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`SlideRailAddSlide`constSource ↗

Add slide, after the current slide, as React's SlideRailAddSlide.

SlideRailAddSlide: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly hidden: boolean;
    readonly icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`SlideRailChooseLayout`constSource ↗

The layout gallery, as React's SlideRailChooseLayout.

SlideRailChooseLayout: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly hidden: boolean;
    readonly icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`SlideRailCollapse`constSource ↗

Hide thumbnails, as React's SlideRailCollapse. toggle: false removes it.

SlideRailCollapse: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly hidden: boolean;
    readonly icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`SlideRailDelete`constSource ↗

Delete the selected slides, as React's SlideRailDelete.

SlideRailDelete: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly hidden: boolean;
    readonly icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`SlideRailDuplicate`constSource ↗

Duplicate the selected slides, as React's SlideRailDuplicate.

SlideRailDuplicate: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly hidden: boolean;
    readonly icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`SlideRailExpand`constSource ↗

Show thumbnails, the one button of the folded rail strip, as React's SlideRailExpand. toggle: false removes it.

SlideRailExpand: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly hidden: boolean;
    readonly icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`SlideRailMoveEarlier`constSource ↗

Move the selected slides earlier, as React's SlideRailMoveEarlier.

SlideRailMoveEarlier: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly hidden: boolean;
    readonly icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`SlideRailMoveLater`constSource ↗

Move the selected slides later, as React's SlideRailMoveLater.

SlideRailMoveLater: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => vue_jsx_runtime.JSX.Element | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly hidden: boolean;
    readonly icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`StatusBarNotes`constSource ↗

The Notes button: shows or hides the speaker notes (useNotesPane), as React's StatusBarNotes.

StatusBarNotes: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly hidden: boolean;
    readonly icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`StatusBarSlideNumber`constSource ↗

"Slide 2 of 5", as React's StatusBarSlideNumber.

StatusBarSlideNumber: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`StatusBarViews`constSource ↗

The view buttons: the editor's view switch (view.presentationView: Normal and Slide Sorter), the same control as the default editor's status area, as React's StatusBarViews.

StatusBarViews: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`StatusBarZoom`constSource ↗

Zoom out, the zoom level with its menu, and zoom in: the editor's PptxEditorZoomPill.

StatusBarZoom: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly hidden: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`ToolbarAction`constSource ↗

A host-owned toolbar action, styled and behaved like the packaged controls, as React's Toolbar.Action. Emits select; the icon prop, the icon slot, or the default slot is its content, else its label as text. A direct child of a preset toolbar goes after the groups and never collapses.

ToolbarAction: DefineComponent<vue.ExtractPropTypes<{
    readonly label: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly active: {
        readonly type: PropType<boolean | undefined>;
        readonly default: undefined;
    };
    readonly disabled: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly disabledReason: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    select: () => true;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly label: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    readonly icon: {
        readonly type: PropType<VNode>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly active: {
        readonly type: PropType<boolean | undefined>;
        readonly default: undefined;
    };
    readonly disabled: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly disabledReason: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{
    onSelect?: (() => any) | undefined;
}>, {
    readonly className: string;
    readonly disabled: boolean;
    readonly icon: VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>;
    readonly asChild: boolean;
    readonly active: boolean | undefined;
    readonly disabledReason: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`ToolbarControl`constSource ↗

One registered control, by registry shape, as React's PptxEditor.ToolbarControl.

ToolbarControl: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly group: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    readonly control: {
        readonly type: PropType<ChromeControl>;
        readonly required: true;
    };
}>, () => VNode, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly group: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    readonly control: {
        readonly type: PropType<ChromeControl>;
        readonly required: true;
    };
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`ToolbarGroup`constSource ↗

A group of controls. Inside a PptxEditorToolbar with the preset on, a built-in id changes that group and any other id adds a host group; with preset false, it renders its slot. A host group's accessible name is its label, else its translated labelKey, else its id.

ToolbarGroup: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly id: {
        readonly type: PropType<ChromeGroupId | (string & {})>;
        readonly required: true;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly labelKey: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly priority: {
        readonly type: NumberConstructor;
        readonly default: undefined;
    };
    readonly pinned: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly after: {
        readonly type: PropType<ChromeGroupId | (string & {})>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly overflowContent: {
        readonly type: PropType<() => VNodeChild>;
        readonly default: undefined;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly id: {
        readonly type: PropType<ChromeGroupId | (string & {})>;
        readonly required: true;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly label: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly labelKey: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly priority: {
        readonly type: NumberConstructor;
        readonly default: undefined;
    };
    readonly pinned: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly after: {
        readonly type: PropType<ChromeGroupId | (string & {})>;
        readonly default: undefined;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
    readonly overflowContent: {
        readonly type: PropType<() => VNodeChild>;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly label: string;
    readonly hidden: boolean;
    readonly after: (string & {}) | ChromeGroupId;
    readonly labelKey: string;
    readonly priority: number;
    readonly pinned: boolean;
    readonly overflowContent: () => VNodeChild;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`ToolbarSeparator`constSource ↗

A vertical rule between controls, as React's Toolbar.Separator.

ToolbarSeparator: DefineComponent<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

`ToolbarSlot`constSource ↗

One registered control. Inside a PptxEditorToolbar with the preset on, it declares an override; anywhere else it renders the control. Default slot content replaces the control; with asChild, its one element renders the control.

ToolbarSlot: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly slotId: {
        readonly type: PropType<ChromeSlotId>;
        readonly required: true;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNodeChild>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>, () => VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly slotId: {
        readonly type: PropType<ChromeSlotId>;
        readonly required: true;
    };
    readonly hidden: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly icon: {
        readonly type: PropType<VNodeChild>;
        readonly default: undefined;
    };
    readonly asChild: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly className: {
        readonly type: StringConstructor;
        readonly default: undefined;
    };
}>> & Readonly<{}>, {
    readonly className: string;
    readonly hidden: boolean;
    readonly icon: VNodeChild;
    readonly asChild: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>

@pptx-editor.dev/vue

Package root

Functions (48)

definePopupfunctionSource ↗

rejectionMessagefunctionSource ↗

requestFindBarfunctionSource ↗

requestSectionRenamefunctionSource ↗

useBackgroundDialogfunctionSource ↗

useBulletFormatfunctionSource ↗

useBulletsAndNumberingDialogfunctionSource ↗

useChromeTranslatefunctionSource ↗

useColumnsDialogfunctionSource ↗

useContextMenuRequestfunctionSource ↗

useContextMenuTargetfunctionSource ↗

useDocumentSearchfunctionSource ↗

useEditorCaretfunctionSource ↗

useEditorColorModefunctionSource ↗

useEditorCommandfunctionSource ↗

useEditorDialogfunctionSource ↗

useEditorEventfunctionSource ↗

useEditorHostDocumentfunctionSource ↗

useEditorSnapshotfunctionSource ↗

useEditorStatefunctionSource ↗

useEditorValueCommandfunctionSource ↗

useEquationDialogfunctionSource ↗

useFontDialogfunctionSource ↗

useFontFamilyfunctionSource ↗

useFontFormatfunctionSource ↗

useFontsfunctionSource ↗

useFontsfunctionSource ↗

useHistoryGroupfunctionSource ↗

useHyperlinkPopupfunctionSource ↗

useHyperlinkPopupInstancefunctionSource ↗

useImageAltTextDialogfunctionSource ↗

useImagePropertiesDialogfunctionSource ↗

useNotesPanefunctionSource ↗

useOpenFailurefunctionSource ↗

usePageSetupDialogfunctionSource ↗

useParagraphDialogfunctionSource ↗

useParagraphFormatfunctionSource ↗

usePptxEditorfunctionSource ↗

usePptxSourcefunctionSource ↗

useReviewAuthorsfunctionSource ↗

useScopeClassNamefunctionSource ↗

useSlideLayoutsfunctionSource ↗

useSlideshowfunctionSource ↗

useToolbarContextfunctionSource ↗

useToolbarLabelfunctionSource ↗

useToolbarLabelForfunctionSource ↗

useTranslationfunctionSource ↗

useZoomfunctionSource ↗

Interfaces (38)

BackgroundDialogFieldsinterfaceSource ↗

ContextMenuPointinterfaceSource ↗

ContextMenuRequestinterfaceSource ↗

DefinePopupOptionsinterfaceSource ↗

DialogCustomizationPropsinterfaceSource ↗

DialogPartPropsinterfaceSource ↗

EquationDialogFieldsinterfaceSource ↗

FindPopupPropsinterfaceSource ↗

ImageAltTextDialogFieldsinterfaceSource ↗

ImagePropertiesDialogFieldsinterfaceSource ↗

OpenFailureContextinterfaceSource ↗

PageSetupDialogFieldsinterfaceSource ↗

PptxEditorDialogSessionPropsinterfaceSource ↗

PptxEditorPopupsinterfaceSource ↗

PptxEditorRefinterfaceSource ↗

RailMenuStateinterfaceSource ↗

SectionMenuStateinterfaceSource ↗

UseBackgroundDialogReturninterfaceSource ↗

UseBulletFormatReturninterfaceSource ↗

UseDialogReturninterfaceSource ↗

UseDocumentSearchReturninterfaceSource ↗

UseEditorColorModeReturninterfaceSource ↗

UseEditorCommandReturninterfaceSource ↗

UseEditorDialogReturninterfaceSource ↗

UseEditorValueCommandReturninterfaceSource ↗

UseFontFamilyReturninterfaceSource ↗

UseFontFormatReturninterfaceSource ↗

UseHistoryGroupReturninterfaceSource ↗

`@pptx-editor.dev/vue`

`definePopup`functionSource ↗

`rejectionMessage`functionSource ↗

`requestFindBar`functionSource ↗

`requestSectionRename`functionSource ↗

`useBackgroundDialog`functionSource ↗

`useBulletFormat`functionSource ↗

`useBulletsAndNumberingDialog`functionSource ↗

`useChromeTranslate`functionSource ↗

`useColumnsDialog`functionSource ↗

`useContextMenuRequest`functionSource ↗

`useContextMenuTarget`functionSource ↗

`useDocumentSearch`functionSource ↗

`useEditorCaret`functionSource ↗

`useEditorColorMode`functionSource ↗

`useEditorCommand`functionSource ↗

`useEditorDialog`functionSource ↗

`useEditorEvent`functionSource ↗

`useEditorHostDocument`functionSource ↗

`useEditorSnapshot`functionSource ↗

`useEditorState`functionSource ↗

`useEditorValueCommand`functionSource ↗

`useEquationDialog`functionSource ↗

`useFontDialog`functionSource ↗

`useFontFamily`functionSource ↗

`useFontFormat`functionSource ↗

`useFonts`functionSource ↗

`useFonts`functionSource ↗

`useHistoryGroup`functionSource ↗

`useHyperlinkPopup`functionSource ↗

`useHyperlinkPopupInstance`functionSource ↗

`useImageAltTextDialog`functionSource ↗

`useImagePropertiesDialog`functionSource ↗

`useNotesPane`functionSource ↗

`useOpenFailure`functionSource ↗

`usePageSetupDialog`functionSource ↗

`useParagraphDialog`functionSource ↗

`useParagraphFormat`functionSource ↗

`usePptxEditor`functionSource ↗

`usePptxSource`functionSource ↗

`useReviewAuthors`functionSource ↗

`useScopeClassName`functionSource ↗

`useSlideLayouts`functionSource ↗

`useSlideshow`functionSource ↗

`useToolbarContext`functionSource ↗

`useToolbarLabel`functionSource ↗

`useToolbarLabelFor`functionSource ↗

`useTranslation`functionSource ↗

`useZoom`functionSource ↗

`BackgroundDialogFields`interfaceSource ↗

`ContextMenuPoint`interfaceSource ↗

`ContextMenuRequest`interfaceSource ↗

`DefinePopupOptions`interfaceSource ↗

`DialogCustomizationProps`interfaceSource ↗

`DialogPartProps`interfaceSource ↗

`EquationDialogFields`interfaceSource ↗

`FindPopupProps`interfaceSource ↗

`ImageAltTextDialogFields`interfaceSource ↗

`ImagePropertiesDialogFields`interfaceSource ↗

`OpenFailureContext`interfaceSource ↗

`PageSetupDialogFields`interfaceSource ↗

`PptxEditorDialogSessionProps`interfaceSource ↗

`PptxEditorPopups`interfaceSource ↗

`PptxEditorRef`interfaceSource ↗

`RailMenuState`interfaceSource ↗

`SectionMenuState`interfaceSource ↗

`UseBackgroundDialogReturn`interfaceSource ↗

`UseBulletFormatReturn`interfaceSource ↗

`UseDialogReturn`interfaceSource ↗

`UseDocumentSearchReturn`interfaceSource ↗

`UseEditorColorModeReturn`interfaceSource ↗

`UseEditorCommandReturn`interfaceSource ↗

`UseEditorDialogReturn`interfaceSource ↗

`UseEditorValueCommandReturn`interfaceSource ↗

`UseFontFamilyReturn`interfaceSource ↗

`UseFontFormatReturn`interfaceSource ↗

`UseHistoryGroupReturn`interfaceSource ↗

`UseHyperlinkPopupReturn`interfaceSource ↗

`UseNotesPaneReturn`interfaceSource ↗

`UseOpenFailureOptions`interfaceSource ↗