@slidev/types/dist/index.d.mts

Shared types declarations for Slidev

import { ComputedRef, MaybeRefOrGetter, Component, App, Ref } from 'vue';
import { Arrayable, Awaitable, ArgumentsType } from '@antfu/utils';
import { CodeToHastOptions, HighlighterGeneric, CodeToHastOptionsCommon, BuiltinLanguage, CodeOptionsThemes, BuiltinTheme, CodeOptionsMeta, Highlighter, LanguageInput } from 'shiki';
import { RouteMeta, RouteComponent, Router, RouteRecordRaw } from 'vue-router';
import YAML from 'yaml';
import { MarkdownItShikiOptions } from '@shikijs/markdown-it';
import { KatexOptions } from 'katex';
import { MermaidConfig } from 'mermaid';
import * as monaco from 'monaco-editor';
import { VitePluginConfig } from 'unocss/vite';
import MagicString from 'magic-string-stack';
import Vue from '@vitejs/plugin-vue';
import VueJsx from '@vitejs/plugin-vue-jsx';
import Icons from 'unplugin-icons/vite';
import Components from 'unplugin-vue-components/vite';
import Markdown from 'unplugin-vue-markdown/vite';
import { ViteInspectOptions } from 'vite-plugin-inspect';
import RemoteAssets from 'vite-plugin-remote-assets';
import { ViteStaticCopyOptions } from 'vite-plugin-static-copy';
import ServerRef from 'vite-plugin-vue-server-ref';

interface CommonArgs {
    entry: string;
    theme?: string;
}
interface ExportArgs extends CommonArgs {
    'output'?: string;
    'format'?: string;
    'timeout'?: number;
    'wait'?: number;
    'wait-until'?: string;
    'range'?: string;
    'dark'?: boolean;
    'with-clicks'?: boolean;
    'executable-path'?: string;
    'with-toc'?: boolean;
    'per-slide'?: boolean;
    'scale'?: number;
    'omit-background'?: boolean;
}
interface BuildArgs extends ExportArgs {
    out: string;
    base?: string;
    download?: boolean;
    inspect: boolean;
}

type RawSingleAtValue = null | undefined | boolean | string | number;
type RawRangeAtValue = null | undefined | false | [string | number, string | number];
type RawAtValue = RawSingleAtValue | RawRangeAtValue;
type NormalizedSingleClickValue = number | string | null;
type NormalizedRangeClickValue = [number, number] | [number, string] | [string, number] | [string, string] | [string | number, string | number] | null;
type NormalizedAtValue = NormalizedSingleClickValue | NormalizedRangeClickValue;
type ClicksElement = Element | string;
interface ClicksInfo {
    /**
     * The absolute start click num
     */
    start: number;
    /**
     * The absolute end click num
     */
    end: number;
    /**
     * The required total click num
     */
    max: number;
    /**
     * The delta for relative clicks
     */
    delta: number;
    /**
     * currentClicks - start
     */
    currentOffset: ComputedRef<number>;
    /**
     * currentOffset === 0
     */
    isCurrent: ComputedRef<boolean>;
    /**
     * Computed ref of whether the click is active
     */
    isActive: ComputedRef<boolean>;
}
interface ClicksContext {
    current: number;
    readonly clicksStart: number;
    readonly relativeSizeMap: Map<ClicksElement, number>;
    readonly maxMap: Map<ClicksElement, number>;
    calculateSince: (at: RawSingleAtValue, size?: number) => ClicksInfo | null;
    calculateRange: (at: RawRangeAtValue) => ClicksInfo | null;
    calculate: (at: RawAtValue) => ClicksInfo | null;
    register: (el: ClicksElement, info: Pick<ClicksInfo, 'delta' | 'max'> | null) => void;
    unregister: (el: ClicksElement) => void;
    readonly isMounted: boolean;
    setup: () => void;
    readonly currentOffset: number;
    readonly total: number;
}

interface CodeRunnerContext {
    /**
     * Options passed to runner via the `runnerOptions` prop.
     */
    options: Record<string, unknown>;
    /**
     * Highlight code with shiki.
     */
    highlight: (code: string, lang: string, options?: Partial<CodeToHastOptions>) => string;
    /**
     * Use (other) code runner to run code.
     */
    run: (code: string, lang: string) => Promise<CodeRunnerOutputs>;
}
interface CodeRunnerOutputHtml {
    /**
     * The HTML to be rendered.
     *
     * Slidev does NOT sanitize the HTML for you - make sure it's from trusted sources or sanitize it before passing it in
     */
    html: string;
}
interface CodeRunnerOutputDom {
    /**
     * The DOM element to be rendered.
     */
    element: HTMLElement;
}
interface CodeRunnerOutputError {
    /**
     * The error message to be displayed.
     */
    error: string;
}
interface CodeRunnerOutputText {
    /**
     * The text to be displayed.
     */
    text: string;
    /**
     * The class to be applied to the text.
     */
    class?: string;
    /**
     * The language to be highlighted.
     */
    highlightLang?: string;
}
type CodeRunnerOutputTextArray = CodeRunnerOutputText[];
type CodeRunnerOutput = CodeRunnerOutputHtml | CodeRunnerOutputError | CodeRunnerOutputText | CodeRunnerOutputTextArray | CodeRunnerOutputDom;
type CodeRunnerOutputs = MaybeRefOrGetter<Arrayable<CodeRunnerOutput>>;
type CodeRunner = (code: string, ctx: CodeRunnerContext) => Awaitable<CodeRunnerOutputs>;
type CodeRunnerProviders = Record<string, CodeRunner>;

type BuiltinLayouts = '404' | 'center' | 'cover' | 'default' | 'end' | 'error' | 'fact' | 'full' | 'iframe-left' | 'iframe-right' | 'iframe' | 'image-left' | 'image-right' | 'image' | 'intro' | 'none' | 'quote' | 'section' | 'statement' | 'two-cols-header' | 'two-cols';

type FrontmatterStyle = 'frontmatter' | 'yaml';
interface SlideInfoBase {
    revision: string;
    frontmatter: Record<string, any>;
    content: string;
    frontmatterRaw?: string;
    note?: string;
    title?: string;
    level?: number;
}
interface SourceSlideInfo extends SlideInfoBase {
    /**
     * The filepath of the markdown file
     */
    filepath: string;
    /**
     * The index of the slide in the markdown file
     */
    index: number;
    /**
     * The range of the slide in the markdown file
     */
    start: number;
    contentStart: number;
    end: number;
    raw: string;
    /**
     * Slides import by this slide.
     */
    imports?: SourceSlideInfo[];
    frontmatterDoc?: YAML.Document;
    frontmatterStyle?: FrontmatterStyle;
}
interface SlideInfo extends SlideInfoBase {
    /**
     * The index of the slide in the presentation
     */
    index: number;
    /**
     * The importers of this slide. `[]` if this slide is the entry markdown file
     */
    importChain?: SourceSlideInfo[];
    /**
     * The source slide where the content is from
     */
    source: SourceSlideInfo;
    noteHTML?: string;
}
/**
 * Editable fields for a slide
 */
type SlidePatch = Partial<Pick<SlideInfoBase, 'content' | 'note' | 'frontmatterRaw'>> & {
    skipHmr?: boolean;
    /**
     * The frontmatter patch (only the changed fields)
     * `null` to remove a field
     */
    frontmatter?: Record<string, any>;
};
/**
 * Metadata for "slidev" field in themes' package.json
 */
interface SlidevThemeMeta {
    defaults?: Partial<SlidevConfig>;
    colorSchema?: 'dark' | 'light' | 'both';
    highlighter?: 'shiki';
}
type SlidevThemeConfig = Record<string, string | number>;
interface SlidevDetectedFeatures {
    katex: boolean;
    /**
     * `false` or referenced module specifiers
     */
    monaco: false | {
        types: string[];
        deps: string[];
    };
    tweet: boolean;
    mermaid: boolean;
}
interface SlidevMarkdown {
    filepath: string;
    raw: string;
    /**
     * All slides in this markdown file
     */
    slides: SourceSlideInfo[];
    errors?: {
        row: number;
        message: string;
    }[];
}
interface SlidevData {
    /**
     * Slides that should be rendered (disabled slides excluded)
     */
    slides: SlideInfo[];
    entry: SlidevMarkdown;
    config: SlidevConfig;
    headmatter: Record<string, unknown>;
    features: SlidevDetectedFeatures;
    themeMeta?: SlidevThemeMeta;
    markdownFiles: Record<string, SlidevMarkdown>;
    /**
     * From watched files to indexes of slides that must be reloaded regardless of the loaded content
     */
    watchFiles: Record<string, Set<number>>;
}
interface SlidevPreparserExtension {
    name?: string;
    transformRawLines?: (lines: string[]) => Promise<void> | void;
    transformSlide?: (content: string, frontmatter: any) => Promise<string | undefined>;
}
type PreparserExtensionLoader = (headmatter: Record<string, unknown>, filepath: string, mode?: string) => Promise<SlidevPreparserExtension[]>;
type RenderContext = 'none' | 'slide' | 'overview' | 'presenter' | 'previewNext';
interface SlideRoute {
    no: number;
    meta: RouteMeta & Required<Pick<RouteMeta, 'slide'>>;
    /**
     * load the slide component itself
     */
    load: () => Promise<{
        default: RouteComponent;
    }>;
    /**
     * Wrapped async component
     */
    component: Component;
}

interface Headmatter extends HeadmatterConfig, Omit<Frontmatter, 'title'> {
    /**
     * Default frontmatter options applied to all slides
     */
    defaults?: Frontmatter;
}
interface HeadmatterConfig extends TransitionOptions {
    /**
     * Title of the slides
     */
    title?: string;
    /**
     * String template to compose title
     *
     * @example "%s - Slidev" - to suffix " - Slidev" to all pages
     * @default '%s - Slidev'
     */
    titleTemplate?: string;
    /**
     * Theme to use for the slides
     *
     * See https://sli.dev/guide/theme-addon#use-theme
     * @default 'default'
     */
    theme?: string;
    /**
     * List of Slidev addons
     *
     * @default []
     */
    addons?: string[];
    /**
     * Download remote assets in local using vite-plugin-remote-assets
     *
     * @default false
     */
    remoteAssets?: boolean | 'dev' | 'build';
    /**
     * Show a download button in the SPA build,
     * could also be a link to custom pdf
     *
     * @default false
     */
    download?: boolean | string;
    /**
     * Show a copy button in code blocks
     *
     * @default true
     */
    codeCopy?: boolean;
    /**
     * The author of the slides
     */
    author?: string;
    /**
     * Information shows on the built SPA
     * Can be a markdown string
     *
     * @default false
     */
    info?: string | boolean;
    /**
     * Prefer highlighter
     *
     * See https://sli.dev/custom/config-highlighter.html
     * @default shiki
     */
    highlighter?: 'shiki';
    /**
     * Enable Twoslash
     *
     * @default true
     */
    twoslash?: boolean | 'dev' | 'build';
    /**
     * Show line numbers in code blocks
     *
     * @default false
     */
    lineNumbers?: boolean;
    /**
     * Force slides color schema
     *
     * @default 'auto'
     */
    colorSchema?: 'dark' | 'light' | 'all' | 'auto';
    /**
     * Router mode for vue-router
     *
     * @default 'history'
     */
    routerMode?: 'hash' | 'history';
    /**
     * Aspect ratio for slides
     * should be like `16/9` or `1:1`
     *
     * @default '16/9'
     */
    aspectRatio?: number;
    /**
     * The actual width for slides canvas.
     * unit in px.
     *
     * @default '980'
     */
    canvasWidth?: number;
    /**
     * Controls whether texts in slides are selectable
     *
     * @default true
     */
    selectable?: boolean;
    /**
     * Configure for themes, will inject intro root styles as
     * `--slidev-theme-x` for attribute `x`
     *
     * This allows themes to have customization options in frontmatter
     * Refer to themes' document for options avaliable
     *
     * @default {}
     */
    themeConfig?: SlidevThemeConfig;
    /**
     * Configure fonts for the slides and app
     *
     * @default {}
     */
    fonts?: FontOptions;
    /**
     * Configure the icon for app
     *
     * @default 'https://cdn.jsdelivr.net/gh/slidevjs/slidev/assets/favicon.png'
     */
    favicon?: string;
    /**
     * Options for drawings
     *
     * @default {}
     */
    drawings?: DrawingsOptions;
    /**
     * URL of PlantUML server used to render diagrams
     *
     * @default https://www.plantuml.com/plantuml
     */
    plantUmlServer?: string;
    /**
     * Enable slides recording
     *
     * @default 'dev'
     */
    record?: boolean | 'dev' | 'build';
    /**
     * Expose the server to inbound requests (listen to `0.0.0.0`)
     *
     * Pass a string to set the password for accessing presenter mode.
     *
     * @default false
     */
    remote?: string | boolean;
    /**
     * Engine for Atomic CSS
     *
     * See https://unocss.dev/
     * @deprecated
     * @default 'unocss'
     */
    css?: 'unocss';
    /**
     * Enable presenter mode
     *
     * @default true
     */
    presenter?: boolean | 'dev' | 'build';
    /**
     * Enable browser exporter
     *
     * @default 'dev'
     */
    browserExporter?: boolean | 'dev' | 'build';
    /**
     * Attributes to apply to the HTML element
     *
     * @default {}
     */
    htmlAttrs?: Record<string, string>;
    /**
     * Suppport MDC syntax
     *
     * See https://github.com/antfu/markdown-it-mdc
     *
     * See https://content.nuxtjs.org/guide/writing/mdc
     *
     * @default false
     */
    mdc?: boolean;
    /**
     * Enable built-in editor
     *
     * @default true
     */
    editor?: boolean;
    /**
     * Enable context menu
     *
     * @default true
     */
    contextMenu?: boolean | 'dev' | 'build' | null;
    /**
     * Enable wake lock
     */
    wakeLock?: boolean | 'dev' | 'build';
    /**
     * Force the filename used when exporting the presentation.
     * The extension, e.g. .pdf, gets automatically added.
     *
     * @default ''
     */
    exportFilename?: string | null;
    /**
     * Enable Monaco
     *
     * See https://sli.dev/custom/config-monaco.html
     * @default true
     */
    monaco?: boolean | 'dev' | 'build';
    /**
     * Where to load monaco types from
     *
     * - `cdn` - load from CDN with `@typescript/ata`
     * - `local` - load from local node_modules
     *
     * @default 'local'
     */
    monacoTypesSource?: 'cdn' | 'local' | 'none';
    /**
     * Additional node packages to load as monaco types
     *
     * @default []
     */
    monacoTypesAdditionalPackages?: string[];
    /**
     * Packages to ignore when loading monaco types
     *
     * @default []
     */
    monacoTypesIgnorePackages?: string[];
    /**
     * Additional local modules to load as dependencies of monaco runnable
     *
     * @default []
     */
    monacoRunAdditionalDeps?: string[];
}
interface Frontmatter extends TransitionOptions {
    /**
     * Slide layout to use
     *
     * Default to 'cover' for the first slide, 'default' for the rest
     */
    layout?: BuiltinLayouts | string;
    /**
     * Custom class added to the slide root element
     */
    class?: string | string[] | Record<string, unknown>;
    /**
     * Manually specified the total clicks needed to this slide
     *
     * When not specified, the clicks will be calculated by the usage of v-clicks
     *
     * See https://sli.dev/guide/animations
     */
    clicks?: number;
    /**
     * Manually specified the total clicks needed to this slide to start
     *
     * @default 0
     */
    clicksStart?: number;
    /**
     * Preload the slide when the previous slide is active
     * @default true
     */
    preload?: boolean;
    /**
     * Completely hide and disable the slide
     */
    hide?: boolean;
    /**
     * Same as `hide`, completely hide and disable the slide
     */
    disabled?: boolean;
    /**
     * Hide the slide for the `<Toc>` components
     *
     * See https://sli.dev/builtin/components#toc
     */
    hideInToc?: boolean;
    /**
     * Override the title for the `<TitleRenderer>` and `<Toc>` components
     * Only if `title` has also been declared
     */
    title?: string;
    /**
     * Override the title level for the `<TitleRenderer>` and `<Toc>` components
     * Only if `title` has also been declared
     */
    level?: number;
    /**
     * Create a route alias that can be used in the URL or with the `<Link>` component
     */
    routeAlias?: string;
    /**
     * Custom zoom level for the slide
     * @default 1
     */
    zoom?: number;
    /**
     * Store the positions of draggable elements
     * Normally you don't need to set this manually
     *
     * See https://sli.dev/features/draggable
     */
    dragPos?: Record<string, string>;
    /**
     * Includes a markdown file
     *
     * See https://sli.dev/guide/syntax.html#importing-slides
     */
    src?: string;
}
interface DrawingsOptions {
    /**
     * Persist the drawings to disk
     * Passing string to specify the directory (default to `.slidev/drawings`)
     *
     * @default false
     */
    persist?: boolean | string;
    /**
     * @default true
     */
    enabled?: boolean | 'dev' | 'build';
    /**
     * Only allow drawing from presenter mode
     *
     * @default false
     */
    presenterOnly?: boolean;
    /**
     * Sync drawing for all instances
     *
     * @default true
     */
    syncAll?: boolean;
}
interface FontOptions {
    /**
     * Sans serif fonts (default fonts for most text)
     */
    sans?: string | string[];
    /**
     * Serif fonts
     */
    serif?: string | string[];
    /**
     * Monospace fonts, for code blocks and etc.
     */
    mono?: string | string[];
    /**
     * Load webfonts for custom CSS (does not apply anywhere by default)
     */
    custom?: string | string[];
    /**
     * Weights for fonts
     *
     * @default [200, 400, 600]
     */
    weights?: string | (string | number)[];
    /**
     * Import italic fonts
     *
     * @default false
     */
    italic?: boolean;
    /**
     * @default 'google'
     */
    provider?: 'none' | 'google' | 'coollabs';
    /**
     * Specify web fonts names, will detect from `sans`, `mono`, `serif` if not provided
     */
    webfonts?: string[];
    /**
     * Specify local fonts names, be excluded from webfonts
     */
    local?: string[];
    /**
     * Use fonts fallback
     *
     * @default true
     */
    fallbacks?: boolean;
}
type BuiltinSlideTransition = 'slide-up' | 'slide-down' | 'slide-left' | 'slide-right' | 'fade' | 'zoom' | 'none';
interface TransitionOptions {
    /**
     * Page transition, powered by Vue's `<TransitionGroup/>`
     *
     * Built-in transitions:
     * - fade
     * - fade-out
     * - slide-left
     * - slide-right
     * - slide-up
     * - slide-down
     *
     * See https://sli.dev/guide/animations.html#pages-transitions
     *
     * See https://vuejs.org/guide/built-ins/transition.html
     */
    transition?: BuiltinSlideTransition | string | TransitionGroupProps | null;
}
interface TransitionGroupProps {
    appear?: boolean;
    persisted?: boolean;
    tag?: string;
    moveClass?: string;
    css?: boolean;
    duration?: number | {
        enter: number;
        leave: number;
    };
    enterFromClass?: string;
    enterActiveClass?: string;
    enterToClass?: string;
    appearFromClass?: string;
    appearActiveClass?: string;
    appearToClass?: string;
    leaveFromClass?: string;
    leaveActiveClass?: string;
    leaveToClass?: string;
}

interface ResolvedSlidevConfigSub {
    export: ResolvedExportOptions;
    drawings: ResolvedDrawingsOptions;
    fonts: ResolvedFontOptions;
}
interface SlidevConfig extends Omit<Required<HeadmatterConfig>, keyof ResolvedSlidevConfigSub>, ResolvedSlidevConfigSub {
}
interface ResolvedFontOptions {
    sans: string[];
    mono: string[];
    serif: string[];
    weights: string[];
    italic: boolean;
    provider: 'none' | 'google' | 'coollabs';
    webfonts: string[];
    local: string[];
}
interface ResolvedDrawingsOptions {
    persist: string | false;
    enabled: boolean | 'dev' | 'build';
    presenterOnly: boolean;
    syncAll: boolean;
}
interface ResolvedExportOptions extends Omit<ExportArgs, 'entry' | 'theme'> {
    withClicks?: boolean;
    executablePath?: string;
    withToc?: boolean;
}

type ContextMenuOption = {
    action: () => void;
    disabled?: boolean;
} & ({
    small?: false;
    icon?: Component | string;
    label: string | Component;
} | {
    small: true;
    icon: Component | string;
    label: string;
});
type ContextMenuItem = ContextMenuOption | 'separator';

declare module 'vite' {
    interface CustomEventMap {
        'slidev:update-slide': {
            no: number;
            data: SlideInfo;
        };
        'slidev:update-note': {
            no: number;
            note: string;
            noteHTML: string;
        };
    }
}

interface RootsInfo {
    cliRoot: string;
    clientRoot: string;
    userRoot: string;
    userPkgJson: Record<string, any>;
    userWorkspaceRoot: string;
}
interface SlidevEntryOptions {
    /**
     * Markdown entry
     */
    entry: string;
    /**
     * Theme id
     */
    theme?: string;
    /**
     * Remote password
     */
    remote?: string;
    /**
     * Enable inspect plugin
     */
    inspect?: boolean;
    /**
     * Build with --download option
     */
    download?: boolean;
    /**
     * Base URL in dev or build mode
     */
    base?: string;
}
interface ResolvedSlidevOptions extends RootsInfo, SlidevEntryOptions {
    data: SlidevData;
    themeRaw: string;
    themeRoots: string[];
    addonRoots: string[];
    /**
     * =`[...themeRoots, ...addonRoots, userRoot]` (`clientRoot` excluded)
     */
    roots: string[];
    mode: 'dev' | 'build' | 'export';
    utils: ResolvedSlidevUtils;
}
interface ResolvedSlidevUtils {
    shiki: HighlighterGeneric<any, any>;
    shikiOptions: MarkdownItShikiOptions;
    katexOptions: KatexOptions | null;
    indexHtml: string;
    define: Record<string, string>;
    iconsResolvePath: string[];
    isMonacoTypesIgnored: (pkg: string) => boolean;
    getLayouts: () => Record<string, string>;
}
interface SlidevServerOptions {
    /**
     * @returns `false` if server should be restarted
     */
    loadData?: (loadedSource: Record<string, string>) => Promise<SlidevData | false>;
}

interface MarkdownTransformContext {
    /**
     * The magic string instance for the current markdown content
     */
    s: MagicString;
    /**
     * The slide info of the current slide
     */
    slide: SlideInfo;
    /**
     * Resolved Slidev options
     */
    options: ResolvedSlidevOptions;
}
type MarkdownTransformer = (ctx: MarkdownTransformContext) => Awaitable<void>;

interface AppContext {
    app: App;
    router: Router;
}
interface MonacoSetupReturn {
    editorOptions?: monaco.editor.IEditorOptions;
}
interface NavOperations {
    next: () => void;
    prev: () => Promise<void>;
    nextSlide: () => void;
    prevSlide: () => Promise<void>;
    go: (index: number) => void;
    goFirst: () => void;
    goLast: () => void;
    downloadPDF: () => Promise<void>;
    toggleDark: () => void;
    toggleOverview: () => void;
    toggleDrawing: () => void;
    escapeOverview: () => void;
    showGotoDialog: () => void;
}
interface ShortcutOptions {
    key: string | Ref<boolean>;
    fn?: () => void;
    autoRepeat?: boolean;
    name?: string;
}
interface ShikiContext {
    /**
     * @deprecated Pass directly the theme name it's supported by Shiki.
     * For custom themes, load it manually via `JSON.parse(fs.readFileSync(path, 'utf-8'))` and pass the raw JSON object instead.
     */
    loadTheme: (path: string) => Promise<any>;
}
type ShikiSetupReturn = Partial<Omit<CodeToHastOptionsCommon<BuiltinLanguage>, 'lang'> & CodeOptionsThemes<BuiltinTheme> & CodeOptionsMeta & {
    setup: (highlighter: Highlighter) => Awaitable<void>;
    langs: (LanguageInput | BuiltinLanguage)[];
}>;
interface TransformersSetupReturn {
    pre: (MarkdownTransformer | false)[];
    preCodeblock: (MarkdownTransformer | false)[];
    postCodeblock: (MarkdownTransformer | false)[];
    post: (MarkdownTransformer | false)[];
}
type ShikiSetup = (shiki: ShikiContext) => Awaitable<ShikiSetupReturn | void>;
type KatexSetup = () => Awaitable<Partial<KatexOptions> | void>;
type UnoSetup = () => Awaitable<Partial<VitePluginConfig> | void>;
type TransformersSetup = () => Awaitable<Partial<TransformersSetupReturn>>;
type PreparserSetup = (context: {
    filepath: string;
    headmatter: Record<string, unknown>;
    mode?: string;
}) => Awaitable<SlidevPreparserExtension[]>;
type MonacoSetup = (m: typeof monaco) => Awaitable<MonacoSetupReturn | void>;
type AppSetup = (context: AppContext) => Awaitable<void>;
type RootSetup = () => Awaitable<void>;
type RoutesSetup = (routes: RouteRecordRaw[]) => RouteRecordRaw[];
type MermaidSetup = () => Awaitable<Partial<MermaidConfig> | void>;
type ShortcutsSetup = (nav: NavOperations, defaultShortcuts: ShortcutOptions[]) => Array<ShortcutOptions>;
type CodeRunnersSetup = (runners: CodeRunnerProviders) => Awaitable<CodeRunnerProviders | void>;
type ContextMenuSetup = (items: ComputedRef<ContextMenuItem[]>) => ComputedRef<ContextMenuItem[]>;
declare const defineShikiSetup: (fn: ShikiSetup) => ShikiSetup;
declare const defineUnoSetup: (fn: UnoSetup) => UnoSetup;
declare const defineMonacoSetup: (fn: MonacoSetup) => MonacoSetup;
declare const defineAppSetup: (fn: AppSetup) => AppSetup;
declare const defineRootSetup: (fn: RootSetup) => RootSetup;
declare const defineRoutesSetup: (fn: RoutesSetup) => RoutesSetup;
declare const defineMermaidSetup: (fn: MermaidSetup) => MermaidSetup;
declare const defineKatexSetup: (fn: KatexSetup) => KatexSetup;
declare const defineShortcutsSetup: (fn: ShortcutsSetup) => ShortcutsSetup;
declare const defineTransformersSetup: (fn: TransformersSetup) => TransformersSetup;
declare const definePreparserSetup: (fn: PreparserSetup) => PreparserSetup;
declare const defineCodeRunnersSetup: (fn: CodeRunnersSetup) => CodeRunnersSetup;
declare const defineContextMenuSetup: (fn: ContextMenuSetup) => ContextMenuSetup;

interface TocItem {
    no: number;
    active?: boolean;
    activeParent?: boolean;
    children: TocItem[];
    hasActiveParent?: boolean;
    level: number;
    titleLevel: number;
    path: string;
    hideInToc?: boolean;
    title?: string;
}

interface SlidevPluginOptions {
    vue?: ArgumentsType<typeof Vue>[0];
    vuejsx?: ArgumentsType<typeof VueJsx>[0];
    markdown?: ArgumentsType<typeof Markdown>[0];
    components?: ArgumentsType<typeof Components>[0];
    icons?: ArgumentsType<typeof Icons>[0];
    remoteAssets?: ArgumentsType<typeof RemoteAssets>[0];
    serverRef?: ArgumentsType<typeof ServerRef>[0];
    unocss?: VitePluginConfig;
    staticCopy?: ViteStaticCopyOptions;
    inspect?: ViteInspectOptions;
}
declare module 'vite' {
    interface UserConfig {
        /**
         * Custom internal plugin options for Slidev (advanced)
         *
         * See https://github.com/slidevjs/slidev/blob/main/packages/slidev/node/options.ts#L50
         */
        slidev?: SlidevPluginOptions;
    }
}

export { type AppContext, type AppSetup, type BuildArgs, type BuiltinSlideTransition, type ClicksContext, type ClicksElement, type ClicksInfo, type CodeRunner, type CodeRunnerContext, type CodeRunnerOutput, type CodeRunnerOutputDom, type CodeRunnerOutputError, type CodeRunnerOutputHtml, type CodeRunnerOutputText, type CodeRunnerOutputTextArray, type CodeRunnerOutputs, type CodeRunnerProviders, type CodeRunnersSetup, type CommonArgs, type ContextMenuItem, type ContextMenuSetup, type DrawingsOptions, type ExportArgs, type FontOptions, type Frontmatter, type FrontmatterStyle, type Headmatter, type HeadmatterConfig, type KatexSetup, type MarkdownTransformContext, type MarkdownTransformer, type MermaidSetup, type MonacoSetup, type MonacoSetupReturn, type NavOperations, type NormalizedAtValue, type NormalizedRangeClickValue, type NormalizedSingleClickValue, type PreparserExtensionLoader, type PreparserSetup, type RawAtValue, type RawRangeAtValue, type RawSingleAtValue, type RenderContext, type ResolvedDrawingsOptions, type ResolvedExportOptions, type ResolvedFontOptions, type ResolvedSlidevConfigSub, type ResolvedSlidevOptions, type ResolvedSlidevUtils, type RootSetup, type RootsInfo, type RoutesSetup, type ShikiContext, type ShikiSetup, type ShikiSetupReturn, type ShortcutOptions, type ShortcutsSetup, type SlideInfo, type SlideInfoBase, type SlidePatch, type SlideRoute, type SlidevConfig, type SlidevData, type SlidevDetectedFeatures, type SlidevEntryOptions, type SlidevMarkdown, type SlidevPluginOptions, type SlidevPreparserExtension, type SlidevServerOptions, type SlidevThemeConfig, type SlidevThemeMeta, type SourceSlideInfo, type TocItem, type TransformersSetup, type TransformersSetupReturn, type TransitionGroupProps, type TransitionOptions, type UnoSetup, defineAppSetup, defineCodeRunnersSetup, defineContextMenuSetup, defineKatexSetup, defineMermaidSetup, defineMonacoSetup, definePreparserSetup, defineRootSetup, defineRoutesSetup, defineShikiSetup, defineShortcutsSetup, defineTransformersSetup, defineUnoSetup };