/// <reference types="vite/client" />
/// <reference types="@sveltepress/vite/types" />
/// <reference types="@sveltejs/kit/vite" />

declare module 'virtual:sveltepress/theme-default' {
  import type { import DocSearchPropsDocSearchProps } from '@sveltepress/docsearch/types'
  import type { import CreateTwoslashSvelteOptionsCreateTwoslashSvelteOptions } from '@sveltepress/twoslash'
  import type { import LoadThemeLoadTheme } from '@sveltepress/vite'
  import type { import SvelteKitPWAOptionsSvelteKitPWAOptions } from '@vite-pwa/sveltekit'
  import type { import BundledThemeBundledTheme } from 'shiki'
  import type { import BundledLanguageBundledLanguage } from 'shiki/langs'
  import type { interface Component<Props extends Record<string, any> = {}, Exports extends Record<string, any> = {}, Bindings extends keyof Props | "" = string>
Can be used to create strongly typed Svelte components.
Example:
You have component library on npm called component-library, from which
you export a component called MyComponent. For Svelte+TypeScript users,
you want to provide typings. Therefore you create a index.d.ts:

import type { Component } from 'svelte';
export declare const MyComponent: Component<{ foo: string }> {}
Typing this makes it possible for IDEs like VS Code with the Svelte extension
to provide intellisense and to use the component like this in a Svelte file
with TypeScript:

<script lang="ts">
	import { MyComponent } from "component-library";
</script>
<MyComponent foo={'bar'} />Component } from 'svelte'

  export interface WithTitle {
    WithTitle.title?: string | undefinedtitle?: string
  }

  export interface LinkItem extends WithTitle {
    LinkItem.icon?: string | undefinedicon?: string
    LinkItem.to?: string | undefinedto?: string
    LinkItem.external?: boolean | undefinedexternal?: boolean
    LinkItem.collapsible?: boolean | undefinedcollapsible?: boolean
    LinkItem.items?: LinkItem[] | undefineditems?: LinkItem[]
  }

  export interface AutoSidebarOptions {
    /**
     * Enable auto-generated sidebar
     */
    AutoSidebarOptions.enabled: boolean
Enable auto-generated sidebarenabled: boolean
    /**
     * Routes directory, default 'src/routes'
     */
    AutoSidebarOptions.routesDir?: string | undefined
Routes directory, default 'src/routes'routesDir?: string
    /**
     * Root paths to generate sidebar for, e.g. ['/guide/', '/reference/']
     * If not specified, auto-detect from top-level route directories
     */
    AutoSidebarOptions.roots?: string[] | undefined
Root paths to generate sidebar for, e.g. ['/guide/', '/reference/']
If not specified, auto-detect from top-level route directoriesroots?: string[]
  }

  export interface DefaultThemeOptions {
    DefaultThemeOptions.navbar?: LinkItem[] | undefinednavbar?: interface Array<T>Array<LinkItem>
    DefaultThemeOptions.github?: string | undefinedgithub?: string
    DefaultThemeOptions.logo?: string | undefinedlogo?: string
    DefaultThemeOptions.sidebar?: AutoSidebarOptions | Record<string, LinkItem[]> | undefinedsidebar?: type Record<K extends keyof any, T> = { [P in K]: T; }
Construct a type with a set of properties K of type TRecord<string, LinkItem[]> | AutoSidebarOptions
    DefaultThemeOptions.editLink?: string | undefinededitLink?: string
    DefaultThemeOptions.discord?: string | undefineddiscord?: string
    DefaultThemeOptions.ga?: string | undefinedga?: string
    
DefaultThemeOptions.pwa?: (SvelteKitPWAOptions & {
    darkManifest?: string;
    precachePages?: boolean | string[];
    precacheClient?: boolean;
}) | undefinedpwa?: import SvelteKitPWAOptionsSvelteKitPWAOptions & {
      darkManifest?: string | undefineddarkManifest?: string
      /**
       * Which prerendered HTML pages to put in the Workbox precache.
       *
       * Default `false` only precaches the homepage so service-worker
       * install/update stays fast on sites with many versions and locales.
       *
       * - `false`: homepage only
       * - `true`: all prerendered HTML (historical versions are still ignored)
       * - `string[]`: URL prefixes, e.g. `['/zh/', '/v/2026-08-27/']`
       */
      precachePages?: boolean | string[] | undefined
Which prerendered HTML pages to put in the Workbox precache.
Default false only precaches the homepage so service-worker
install/update stays fast on sites with many versions and locales.

false: homepage only
true: all prerendered HTML (historical versions are still ignored)
string[]: URL prefixes, e.g. ['/zh/', '/v/2026-08-27/']
precachePages?: boolean | string[]
      /**
       * Which client files to put in the Workbox precache.
       *
       * Default `false` only precaches the app shell (SvelteKit entry,
       * hashed CSS/fonts, and root icons) so service-worker install/update
       * stays fast on sites with many pages. Per-route nodes and chunks
       * are fetched on demand.
       *
       * - `false`: app shell only
       * - `true`: every matching client file (the previous catch-all glob)
       */
      precacheClient?: boolean | undefined
Which client files to put in the Workbox precache.
Default false only precaches the app shell (SvelteKit entry,
hashed CSS/fonts, and root icons) so service-worker install/update
stays fast on sites with many pages. Per-route nodes and chunks
are fetched on demand.

false: app shell only
true: every matching client file (the previous catch-all glob)
precacheClient?: boolean
    }
    DefaultThemeOptions.docsearch?: Omit<DocSearchProps, "theme" | "container"> | undefineddocsearch?: type Omit<T, K extends keyof any> = { [P in Exclude<keyof T, K>]: T[P]; }
Construct a type with the properties of T except for those in type K.Omit<import DocSearchPropsDocSearchProps, 'container' | 'theme'>
    DefaultThemeOptions.search?: string | boolean | Component<{}, {}, string> | undefinedsearch?: interface Component<Props extends Record<string, any> = {}, Exports extends Record<string, any> = {}, Bindings extends keyof Props | "" = string>
Can be used to create strongly typed Svelte components.
Example:
You have component library on npm called component-library, from which
you export a component called MyComponent. For Svelte+TypeScript users,
you want to provide typings. Therefore you create a index.d.ts:

import type { Component } from 'svelte';
export declare const MyComponent: Component<{ foo: string }> {}
Typing this makes it possible for IDEs like VS Code with the Svelte extension
to provide intellisense and to use the component like this in a Svelte file
with TypeScript:

<script lang="ts">
	import { MyComponent } from "component-library";
</script>
<MyComponent foo={'bar'} />Component | string | boolean
    
DefaultThemeOptions.themeColor?: {
    light: string;
    dark: string;
    primary?: string;
    primaryDeep?: string;
    hover?: string;
    gradient?: {
        start: string;
        end: string;
    };
} | undefinedthemeColor?: {
      light: stringlight: string
      dark: stringdark: string
      primary?: string | undefinedprimary?: string
      /**
       * Darker variant of primary, used for accent text on light backgrounds
       * where the primary color alone lacks contrast.
       * Defaults to `#e11d48` when primary is not customized, otherwise falls back to primary.
       */
      primaryDeep?: string | undefined
Darker variant of primary, used for accent text on light backgrounds
where the primary color alone lacks contrast.
Defaults to #e11d48 when primary is not customized, otherwise falls back to primary.primaryDeep?: string
      hover?: string | undefinedhover?: string
      
gradient?: {
    start: string;
    end: string;
} | undefinedgradient?: {
        start: stringstart: string
        end: stringend: string
      }
    }
    
DefaultThemeOptions.highlighter?: {
    languages?: BundledLanguage[];
    themeLight?: BundledTheme;
    themeDark?: BundledTheme;
    twoslash?: boolean | CreateTwoslashSvelteOptions;
    codeCollapseLines?: number;
} | undefinedhighlighter?: {
      languages?: BundledLanguage[] | undefinedlanguages?: import BundledLanguageBundledLanguage[]
      themeLight?: anythemeLight?: import BundledThemeBundledTheme
      themeDark?: anythemeDark?: import BundledThemeBundledTheme
      twoslash?: anytwoslash?: boolean | import CreateTwoslashSvelteOptionsCreateTwoslashSvelteOptions
      /**
       * Code blocks taller than this many lines start collapsed with an
       * "Expand code" bar. Set to 0 to disable collapsing.
       * @default 30
       */
      codeCollapseLines?: number | undefined
Code blocks taller than this many lines start collapsed with an
"Expand code" bar. Set to 0 to disable collapsing.
@default30codeCollapseLines?: number
    }
    
DefaultThemeOptions.i18n?: {
    navbarMenu?: string;
    heroCode?: {
        title?: string;
        messageBefore?: string;
        messageStrong?: string;
        messageAfter?: string;
        tipLabel?: string;
        counterLabel?: string;
    };
    onThisPage?: string;
    suggestChangesToThisPage?: string;
    lastUpdateAt?: string;
    previousPage?: string;
    nextPage?: string;
    expansionTitle?: string;
    expandCode?: string;
    pwa?: {
        tip?: string;
        reload?: string;
        close?: string;
        appReadyToWorkOffline?: string;
        newContentAvailable?: string;
    };
    ... 22 more ...;
    searchClear?: string;
} | undefinedi18n?: {
      navbarMenu?: string | undefinednavbarMenu?: string
      
heroCode?: {
    title?: string;
    messageBefore?: string;
    messageStrong?: string;
    messageAfter?: string;
    tipLabel?: string;
    counterLabel?: string;
} | undefinedheroCode?: {
        title?: string | undefinedtitle?: string
        messageBefore?: string | undefinedmessageBefore?: string
        messageStrong?: string | undefinedmessageStrong?: string
        messageAfter?: string | undefinedmessageAfter?: string
        tipLabel?: string | undefinedtipLabel?: string
        counterLabel?: string | undefinedcounterLabel?: string
      }
      onThisPage?: string | undefinedonThisPage?: string
      suggestChangesToThisPage?: string | undefinedsuggestChangesToThisPage?: string
      lastUpdateAt?: string | undefinedlastUpdateAt?: string
      previousPage?: string | undefinedpreviousPage?: string
      nextPage?: string | undefinednextPage?: string
      expansionTitle?: string | undefinedexpansionTitle?: string
      /** Label of the expand bar on collapsed long code blocks */
      expandCode?: string | undefined
Label of the expand bar on collapsed long code blocksexpandCode?: string
      
pwa?: {
    tip?: string;
    reload?: string;
    close?: string;
    appReadyToWorkOffline?: string;
    newContentAvailable?: string;
} | undefinedpwa?: {
        tip?: string | undefinedtip?: string
        reload?: string | undefinedreload?: string
        close?: string | undefinedclose?: string
        appReadyToWorkOffline?: string | undefinedappReadyToWorkOffline?: string
        newContentAvailable?: string | undefinednewContentAvailable?: string
      }
      footnoteLabel?: string | undefinedfootnoteLabel?: string
      /** Label of the language switcher trigger. */
      localeSwitcher?: string | undefined
Label of the language switcher trigger.localeSwitcher?: string
      /** Notice shown after switching locale fell back to that locale's home. */
      localePageUnavailable?: string | undefined
Notice shown after switching locale fell back to that locale's home.localePageUnavailable?: string
      versionSelector?: string | undefinedversionSelector?: string
      versionPageUnavailable?: string | undefinedversionPageUnavailable?: string
      versionDeprecated?: string | undefinedversionDeprecated?: string
      versionEol?: string | undefinedversionEol?: string
      versionViewCurrent?: string | undefinedversionViewCurrent?: string
      versionDeprecatedLabel?: string | undefinedversionDeprecatedLabel?: string
      versionEolLabel?: string | undefinedversionEolLabel?: string
      versionSearchUnavailable?: string | undefinedversionSearchUnavailable?: string
      /** Template for page and section badges. Use `{version}` for the version label. */
      versionNewLabel?: string | undefined
Template for page and section badges. Use {version} for the version label.versionNewLabel?: string
      /** Compact badge shown beside changed sidebar pages and table-of-contents sections. */
      versionNavigationNewLabel?: string | undefined
Compact badge shown beside changed sidebar pages and table-of-contents sections.versionNavigationNewLabel?: string
      versionChangesSelector?: string | undefinedversionChangesSelector?: string
      versionChangesNewPages?: string | undefinedversionChangesNewPages?: string
      versionChangesUpdatedPages?: string | undefinedversionChangesUpdatedPages?: string
      versionChangesNoBaseline?: string | undefinedversionChangesNoBaseline?: string
      versionChangesEmpty?: string | undefinedversionChangesEmpty?: string
      searchPlaceholder?: string | undefinedsearchPlaceholder?: string
      searchNoResults?: string | undefinedsearchNoResults?: string
      searchDevNotice?: string | undefinedsearchDevNotice?: string
      searchClose?: string | undefinedsearchClose?: string
      searchClear?: string | undefinedsearchClear?: string
    }
    
DefaultThemeOptions.preBuildIconifyIcons?: {
    [iconSetName: string]: string[];
} | undefinedpreBuildIconifyIcons?: {
      [iconSetName: stringiconSetName: string]: string[]
    }
  }
  export type type ThemeDefault = LoadTheme<DefaultThemeOptions>ThemeDefault = import LoadThemeLoadTheme<DefaultThemeOptions>

  const const options: DefaultThemeOptionsoptions: DefaultThemeOptions
  export default const options: DefaultThemeOptionsoptions
}

declare module '@sveltepress/theme-default/context' {
  import type { interface Writable<T>
Writable interface for both updating and subscribing.Writable } from 'svelte/store'

  export interface SveltepressContext {
    SveltepressContext.isDark: Writable<boolean>isDark: interface Writable<T>
Writable interface for both updating and subscribing.Writable<boolean>
  }
  export const const SVELTEPRESS_CONTEXT_KEY: symbolSVELTEPRESS_CONTEXT_KEY: symbol
  export const const TITLE_ROW_ACTION_KEY: symbolTITLE_ROW_ACTION_KEY: symbol

  export interface TitleRowAction {
    TitleRowAction.href: stringhref: string
    TitleRowAction.label: stringlabel: string
  }

  export interface TitleRowActionContext {
    readonly TitleRowActionContext.current: TitleRowAction | undefinedcurrent: TitleRowAction | undefined
  }
}

declare module 'virtual:sveltepress/theme-default/versioning' {
  export * from '@sveltepress/theme-default/dist/components/versioning'
}

declare module 'virtual:sveltepress/theme-default/VersionSelector.svelte' {
  import type { interface Component<Props extends Record<string, any> = {}, Exports extends Record<string, any> = {}, Bindings extends keyof Props | "" = string>
Can be used to create strongly typed Svelte components.
Example:
You have component library on npm called component-library, from which
you export a component called MyComponent. For Svelte+TypeScript users,
you want to provide typings. Therefore you create a index.d.ts:

import type { Component } from 'svelte';
export declare const MyComponent: Component<{ foo: string }> {}
Typing this makes it possible for IDEs like VS Code with the Svelte extension
to provide intellisense and to use the component like this in a Svelte file
with TypeScript:

<script lang="ts">
	import { MyComponent } from "component-library";
</script>
<MyComponent foo={'bar'} />Component } from 'svelte'

  const 
const component: Component<{
    mobile?: boolean;
}, {}, string>component: interface Component<Props extends Record<string, any> = {}, Exports extends Record<string, any> = {}, Bindings extends keyof Props | "" = string>
Can be used to create strongly typed Svelte components.
Example:
You have component library on npm called component-library, from which
you export a component called MyComponent. For Svelte+TypeScript users,
you want to provide typings. Therefore you create a index.d.ts:

import type { Component } from 'svelte';
export declare const MyComponent: Component<{ foo: string }> {}
Typing this makes it possible for IDEs like VS Code with the Svelte extension
to provide intellisense and to use the component like this in a Svelte file
with TypeScript:

<script lang="ts">
	import { MyComponent } from "component-library";
</script>
<MyComponent foo={'bar'} />Component<{ mobile?: boolean | undefinedmobile?: boolean }>
  export default 
const component: Component<{
    mobile?: boolean;
}, {}, string>component
}

declare module 'virtual:sveltepress/theme-default/VersionFallbackNotice.svelte' {
  import type { interface Component<Props extends Record<string, any> = {}, Exports extends Record<string, any> = {}, Bindings extends keyof Props | "" = string>
Can be used to create strongly typed Svelte components.
Example:
You have component library on npm called component-library, from which
you export a component called MyComponent. For Svelte+TypeScript users,
you want to provide typings. Therefore you create a index.d.ts:

import type { Component } from 'svelte';
export declare const MyComponent: Component<{ foo: string }> {}
Typing this makes it possible for IDEs like VS Code with the Svelte extension
to provide intellisense and to use the component like this in a Svelte file
with TypeScript:

<script lang="ts">
	import { MyComponent } from "component-library";
</script>
<MyComponent foo={'bar'} />Component } from 'svelte'

  const const component: Component<{}, {}, string>component: interface Component<Props extends Record<string, any> = {}, Exports extends Record<string, any> = {}, Bindings extends keyof Props | "" = string>
Can be used to create strongly typed Svelte components.
Example:
You have component library on npm called component-library, from which
you export a component called MyComponent. For Svelte+TypeScript users,
you want to provide typings. Therefore you create a index.d.ts:

import type { Component } from 'svelte';
export declare const MyComponent: Component<{ foo: string }> {}
Typing this makes it possible for IDEs like VS Code with the Svelte extension
to provide intellisense and to use the component like this in a Svelte file
with TypeScript:

<script lang="ts">
	import { MyComponent } from "component-library";
</script>
<MyComponent foo={'bar'} />Component
  export default const component: Component<{}, {}, string>component
}

declare module 'virtual:sveltepress/theme-default/VersionLifecycleBanner.svelte' {
  import type { interface Component<Props extends Record<string, any> = {}, Exports extends Record<string, any> = {}, Bindings extends keyof Props | "" = string>
Can be used to create strongly typed Svelte components.
Example:
You have component library on npm called component-library, from which
you export a component called MyComponent. For Svelte+TypeScript users,
you want to provide typings. Therefore you create a index.d.ts:

import type { Component } from 'svelte';
export declare const MyComponent: Component<{ foo: string }> {}
Typing this makes it possible for IDEs like VS Code with the Svelte extension
to provide intellisense and to use the component like this in a Svelte file
with TypeScript:

<script lang="ts">
	import { MyComponent } from "component-library";
</script>
<MyComponent foo={'bar'} />Component } from 'svelte'

  const const component: Component<{}, {}, string>component: interface Component<Props extends Record<string, any> = {}, Exports extends Record<string, any> = {}, Bindings extends keyof Props | "" = string>
Can be used to create strongly typed Svelte components.
Example:
You have component library on npm called component-library, from which
you export a component called MyComponent. For Svelte+TypeScript users,
you want to provide typings. Therefore you create a index.d.ts:

import type { Component } from 'svelte';
export declare const MyComponent: Component<{ foo: string }> {}
Typing this makes it possible for IDEs like VS Code with the Svelte extension
to provide intellisense and to use the component like this in a Svelte file
with TypeScript:

<script lang="ts">
	import { MyComponent } from "component-library";
</script>
<MyComponent foo={'bar'} />Component
  export default const component: Component<{}, {}, string>component
}