astro 0.25.2 → 0.26.0

package/dist/types/@types/astro.d.ts

@@ -2,10 +2,11 @@
 import type { AddressInfo } from 'net';
 import type * as babel from '@babel/core';
 import type * as vite from 'vite';
-import type { z } from 'zod';
+import { z } from 'zod';
+import type { ShikiConfig, Plugin } from '@astrojs/markdown-remark';
 import type { AstroConfigSchema } from '../core/config';
 import type { AstroComponentFactory, Metadata } from '../runtime/server';
-import type { AstroRequest } from '../core/render/request';
+import type { ViteConfigWithSSR } from '../core/create-vite';
 export type { SSRManifest } from '../core/app/types';
 export interface AstroBuiltinProps {
     'client:load'?: boolean;
@@ -25,18 +26,13 @@ export interface AstroComponentMetadata {
 }
 /** The flags supported by the Astro CLI */
 export interface CLIFlags {
-    projectRoot?: string;
+    root?: string;
     site?: string;
-    sitemap?: boolean;
     host?: string | boolean;
-    hostname?: string;
     port?: number;
     config?: string;
-    /** @deprecated */
-    experimentalStaticBuild?: boolean;
     experimentalSsr?: boolean;
     experimentalIntegrations?: boolean;
-    legacyBuild?: boolean;
     drafts?: boolean;
 }
 export interface BuildConfig {
@@ -50,24 +46,56 @@ export interface BuildConfig {
  * Docs: https://docs.astro.build/reference/api-reference/#astro-global
  */
 export interface AstroGlobal extends AstroGlobalPartial {
+    /** get the current canonical URL */
+    canonicalURL: URL;
+    /** get page params (dynamic pages only) */
+    params: Params;
     /** set props for this astro component (along with default values) */
     props: Record<string, number | string | any>;
     /** get information about this page */
-    request: AstroRequest;
+    request: Request;
     /** see if slots are used */
     slots: Record<string, true | undefined> & {
         has(slotName: string): boolean;
-        render(slotName: string): Promise<string>;
+        render(slotName: string, args?: any[]): Promise<string>;
     };
 }
 export interface AstroGlobalPartial {
-    fetchContent<T = any>(globStr: string): Promise<FetchContentResult<T>[]>;
     /**
      * @deprecated since version 0.24. See the {@link https://astro.build/deprecated/resolve upgrade guide} for more details.
      */
     resolve: (path: string) => string;
+    /** @deprecated Use `Astro.glob()` instead. */
+    fetchContent(globStr: string): Promise<any[]>;
+    glob(globStr: `${any}.astro`): Promise<ComponentInstance[]>;
+    glob<T extends Record<string, any>>(globStr: `${any}.md`): Promise<MarkdownInstance<T>[]>;
+    glob<T extends Record<string, any>>(globStr: string): Promise<T[]>;
     site: URL;
 }
+declare type ServerConfig = {
+    /**
+     * @name server.host
+     * @type {string | boolean}
+     * @default `false`
+     * @version 0.24.0
+     * @description
+     * Set which network IP addresses the dev server should listen on (i.e. 	non-localhost IPs).
+     * - `false` - do not expose on a network IP address
+     * - `true` - listen on all addresses, including LAN and public addresses
+     * - `[custom-address]` - expose on a network IP address at `[custom-address]`
+     */
+    host?: string | boolean;
+    /**
+     * @name server.port
+     * @type {number}
+     * @default `3000`
+     * @description
+     * Set which port the dev server should listen on.
+     *
+     * If the given port is already in use, Astro will automatically try the next available port.
+     */
+    port?: number;
+};
 /**
  * Astro User Config
  * Docs: https://docs.astro.build/reference/configuration-reference/
@@ -80,48 +108,48 @@ export interface AstroUserConfig {
      */
     /**
      * @docs
-     * @name projectRoot
-     * @cli --project-root
+     * @name root
+     * @cli --root
      * @type {string}
      * @default `"."` (current working directory)
      * @summary Set the project root. The project root is the directory where your Astro project (and all `src`, `public` and `package.json` files) live.
      * @description  You should only provide this option if you run the `astro` CLI commands in a directory other than the project root directory. Usually, this option is provided via the CLI instead of the `astro.config.js` file, since Astro needs to know your project root before it can locate your config file.
      *
-     * If you provide a relative path (ex: `--project-root: './my-project'`) Astro will resolve it against your current working directory.
+     * If you provide a relative path (ex: `--root: './my-project'`) Astro will resolve it against your current working directory.
      *
      * #### Examples
      *
      * ```js
      * {
-     *   projectRoot: './my-project-directory'
+     *   root: './my-project-directory'
      * }
      * ```
      * ```bash
-     * $ astro build --project-root ./my-project-directory
+     * $ astro build --root ./my-project-directory
      * ```
      */
-    projectRoot?: string;
+    root?: string;
     /**
      * @docs
-     * @name dist
+     * @name srcDir
      * @type {string}
-     * @default `"./dist"`
-     * @description Set the directory that `astro build` writes your final build to.
+     * @default `"./src"`
+     * @description Set the directory that Astro will read your site from.
      *
      * The value can be either an absolute file system path or a path relative to the project root.
      *
      * ```js
      * {
-     *   dist: './my-custom-build-directory'
+     *   srcDir: './www'
      * }
      * ```
      */
-    dist?: string;
+    srcDir?: string;
     /**
      * @docs
-     * @name public
+     * @name publicDir
      * @type {string}
-     * @default `"./public"`
+     * @default `"./publicDir"`
      * @description
      * Set the directory for your static assets. Files in this directory are served at `/` during dev and copied to your build directory during build. These files are always served or copied as-is, without transform or bundling.
      *
@@ -129,155 +157,90 @@ export interface AstroUserConfig {
      *
      * ```js
      * {
-     *   public: './my-custom-public-directory'
+     *   publicDir: './my-custom-publicDir-directory'
      * }
      * ```
      */
-    public?: string;
+    publicDir?: string;
     /**
      * @docs
-     * @name integrations
-     * @type {AstroIntegration[]}
-     * @default `[]`
-     * @description
-     * Add Integrations to your project to extend Astro.
-     *
-     * Integrations are your one-stop shop to add new frameworks (like Solid.js), new features (like sitemaps), and new libraries (like Partytown and Turbolinks).
-     *
-     * Setting this configuration will disable Astro's default integration, so it is recommended to provide a renderer for every framework that you use:
+     * @name outDir
+     * @type {string}
+     * @default `"./outDir"`
+     * @description Set the directory that `astro build` writes your final build to.
      *
-     * Note: Integrations are currently under active development, and only first-party integrations are supported. In the future, 3rd-party integrations will be allowed.
+     * The value can be either an absolute file system path or a path relative to the project root.
      *
      * ```js
-     * import react from '@astrojs/react';
-     * import vue from '@astrojs/vue';
      * {
-     *   // Example: Use Astro with Vue + React, and no other frameworks.
-     *   integrations: [react(), vue()]
+     *   outDir: './my-custom-build-directory'
      * }
      * ```
      */
-    integrations?: AstroIntegration[];
+    outDir?: string;
     /**
      * @docs
-     * @name adapter
-     * @type {AstroIntegration}
-     * @default `undefined`
+     * @name site
+     * @type {string}
      * @description
-     * Add an adapter to build for SSR (server-side rendering). An adapter makes it easy to connect a deployed Astro app to a hosting provider or runtime environment.
+     * Your final, deployed URL. Astro uses this full URL to generate your sitemap and canonical URLs in your final build. It is strongly recommended that you set this configuration to get the most out of Astro.
+     *
+     * ```js
+     * {
+     *   site: 'https://www.my-site.dev'
+     * }
+     * ```
      */
-    adapter?: AstroIntegration;
-    /** @deprecated - Use "integrations" instead. Run Astro to learn more about migrating. */
-    renderers?: string[];
+    site?: string;
     /**
      * @docs
-     * @name markdownOptions
-     * @type {{render: MarkdownRenderOptions}}
-     * @see [Markdown guide](/en/guides/markdown-content/)
+     * @name base
+     * @type {string}
      * @description
-     * Configure how markdown files (`.md`) are rendered.
+     * The base path you're deploying to. Astro will match this pathname during development so that your development experience matches your build environment as closely as possible. In the example below, `astro dev` will start your server at `/docs`.
      *
      * ```js
-     * import { defineConfig } from "astro/config";
-     * import astroRemark from "@astrojs/markdown-remark";
-     * import customRehypePlugin from "/path/to/rehypePlugin.mjs";
+     * {
+     *   base: '/docs'
+     * }
+     * ```
+     */
+    base?: string;
+    /**
+     * @docs
+     * @name trailingSlash
+     * @type {('always' | 'never' | 'ignore')}
+     * @default `'always'`
+     * @see buildOptions.pageUrlFormat
+     * @description
      *
-     * export default defineConfig({
-     *   // Enable Custom Markdown options, plugins, etc.
-     *   markdownOptions: {
-     *     render: [
-     *       // The Remark parser to parse Markdown content
-     *       astroRemark,
-     *       {
-     *         // Add a Remark plugin to your project.
-     *         remarkPlugins: ["remark-code-titles"],
+     * Set the route matching behavior of the dev server. Choose from the following options:
+     *   - `'always'` - Only match URLs that include a trailing slash (ex: "/foo/")
+     *   - `'never'` - Never match URLs that include a trailing slash (ex: "/foo")
+     *   - `'ignore'` - Match URLs regardless of whether a trailing "/" exists
      *
-     *         // Add a Rehype plugin to your project.
-     *         rehypePlugins: [
-     *           "rehype-slug",
-     *           [customRehypePlugin, { configKey: "value" }],
-     *           ["rehype-autolink-headings", { behavior: "prepend" }],
-     *         ],
-     *       },
-     *     ],
-     *   },
-     * });
+     * Use this configuration option if your production host has strict handling of how trailing slashes work or do not work.
+     *
+     * You can also set this if you prefer to be more strict yourself, so that URLs with or without trailing slashes won't work during development.
+     *
+     * ```js
+     * {
+     *   // Example: Require a trailing slash during development
+     *   trailingSlash: 'always'
+     * }
      * ```
      */
-    markdownOptions?: {
-        render?: MarkdownRenderOptions;
-    };
+    trailingSlash?: 'always' | 'never' | 'ignore';
     /**
      * @docs
      * @kind heading
      * @name Build Options
      */
-    buildOptions?: {
-        /**
-         * @docs
-         * @name buildOptions.site
-         * @type {string}
-         * @description
-         * Your final, deployed URL. Astro uses this full URL to generate your sitemap and canonical URLs in your final build. It is strongly recommended that you set this configuration to get the most out of Astro.
-         *
-         * Astro will match the site pathname during development so that your development experience matches your build environment as closely as possible. In the example below, `astro dev` will start your server at `http://localhost:3000/docs`.
-         *
-         * ```js
-         * {
-         *   buildOptions: {
-         *     // Example: Tell Astro the final URL of your deployed website.
-         * 	   site: 'https://www.my-site.dev/docs'
-         *   }
-         * }
-         * ```
-         */
-        site?: string;
-        /**
-         * @docs
-         * @name buildOptions.sitemap
-         * @type {boolean}
-         * @default `true`
-         * @description
-         * Generate a sitemap for your build. Set to false to disable.
-         *
-         * Astro will automatically generate a sitemap including all generated pages on your site. If you need more control over your sitemap, consider generating it yourself using a [Non-HTML Page](/en/core-concepts/astro-pages/#non-html-pages).
-         *
-         * ```js
-         * {
-         *   buildOptions: {
-         *     // Example: Disable automatic sitemap generation
-         * 	   sitemap: false
-         *   }
-         * }
-         * ```
-         */
-        sitemap?: boolean;
-        /**
-         * @docs
-         * @name buildOptions.sitemapFilter
-         * @typeraw {(page: string) => boolean}
-         * @see buildOptions.sitemap
-         * @description
-         * By default, all pages are included in your generated sitemap.
-         * You can filter included pages by URL using `buildOptions.sitemapFilter`.
-         *
-         * The `page` function parameter is the full URL of your rendered page, including your `buildOptions.site` domain.
-         * Return `true` to include a page in your sitemap, and `false` to remove it.
-         *
-         * ```js
-         * {
-         *   buildOptions: {
-         * 	   sitemap: true
-         * 	   sitemapFilter: (page) => page !== 'http://example.com/secret-page')
-         *   }
-         * }
-         * ```
-         */
-        sitemapFilter?: (page: string) => boolean;
+    build?: {
         /**
          * @docs
-         * @name buildOptions.pageUrlFormat
-         * @type {('file' | 'directory')}
+         * @name build.format
+         * @typeraw {('file' | 'directory')}
          * @default `'directory'`
          * @description
          * Control the output file format of each page.
@@ -286,17 +249,72 @@ export interface AstroUserConfig {
          *
          * ```js
          * {
-         *   buildOptions: {
+         *   build: {
          *     // Example: Generate `page.html` instead of `page/index.html` during build.
-         * 	   pageUrlFormat: 'file'
+         *     format: 'file'
          *   }
          * }
          * ```
          */
-        pageUrlFormat?: 'file' | 'directory';
+        format?: 'file' | 'directory';
+    };
+    /**
+     * @docs
+     * @kind heading
+     * @name Server Options
+     * @description
+     *
+     * Customize the Astro dev server, used by both `astro dev` and `astro serve`.
+     *
+     * ```js
+     * {
+     *   server: {port: 1234, host: true}
+     * }
+     * ```
+     *
+     * To set different configuration based on the command run ("dev", "preview") a function can also be passed to this configuration option.
+     *
+     * ```js
+     * {
+     *   // Example: Use the function syntax to customize based on command
+     *   server: (command) => ({port: command === 'dev' ? 3000 : 4000})
+     * }
+     * ```
+     */
+    /**
+     * @docs
+     * @name server.host
+     * @type {string | boolean}
+     * @default `false`
+     * @version 0.24.0
+     * @description
+     * Set which network IP addresses the dev server should listen on (i.e. 	non-localhost IPs).
+     * - `false` - do not expose on a network IP address
+     * - `true` - listen on all addresses, including LAN and public addresses
+     * - `[custom-address]` - expose on a network IP address at `[custom-address]`
+     */
+    /**
+     * @docs
+     * @name server.port
+     * @type {number}
+     * @default `3000`
+     * @description
+     * Set which port the dev server should listen on.
+     *
+     * If the given port is already in use, Astro will automatically try the next available port.
+     */
+    server?: ServerConfig | ((options: {
+        command: 'dev' | 'preview';
+    }) => ServerConfig);
+    /**
+     * @docs
+     * @kind heading
+     * @name Markdown Options
+     */
+    markdown?: {
         /**
          * @docs
-         * @name buildOptions.drafts
+         * @name markdown.drafts
          * @type {boolean}
          * @default `false`
          * @description
@@ -306,110 +324,114 @@ export interface AstroUserConfig {
          *
          * ```js
          * {
-         *   buildOptions: {
+         *   markdown: {
          *     // Example: Include all drafts in your final build
-         * 	   drafts: true,
+         *     drafts: true,
          *   }
          * }
          * ```
          */
         drafts?: boolean;
-        /**
-         * Enables "legacy build mode" for compatibility with older Astro versions.
-         * Default: false
-         */
-        legacyBuild?: boolean;
-        /**
-         * @deprecated
-         * Experimental: Enables "static build mode" for faster builds.
-         * Default: true
-         */
-        experimentalStaticBuild?: boolean;
-        /**
-         * Enable a build for SSR support.
-         * Default: false
-         */
-        experimentalSsr?: boolean;
-    };
-    /**
-     * @docs
-     * @kind heading
-     * @name Dev Options
-     */
-    devOptions?: {
         /**
          * @docs
-         * @name devOptions.host
-         * @type {string | boolean}
-         * @default `false`
-         * @version 0.24.0
+         * @name markdown.shikiConfig
+         * @type {ShikiConfig}
          * @description
-         * Set which network IP addresses the dev server should listen on (i.e. 	non-localhost IPs).
-         * - `false` - do not expose on a network IP address
-         * - `true` - listen on all addresses, including LAN and public addresses
-         * - `[custom-address]` - expose on a network IP address at `[custom-address]`
+         * Shiki configuration options. See [the markdown configuration docs](https://docs.astro.build/en/guides/markdown-content/#shiki-configuration) for usage.
          */
-        host?: string | boolean;
+        shikiConfig?: ShikiConfig;
         /**
          * @docs
-         * @name devOptions.hostname
-         * @type {string}
-         * @default `'localhost'`
-         * @deprecated Use `host` instead
+         * @name markdown.syntaxHighlight
+         * @type {'shiki' | 'prism' | false}
+         * @default `shiki`
          * @description
-         * > **This option is deprecated.** Consider using `host` instead.
+         * Which syntax highlighter to use, if any.
+         * - `shiki` - use the [Shiki](https://github.com/shikijs/shiki) highlighter
+         * - `prism` - use the [Prism](https://prismjs.com/) highlighter
+         * - `false` - do not apply syntax highlighting.
          *
-         * Set which IP addresses the dev server should listen on. Set this to 0.0.0.0 to listen on all addresses, including LAN and public addresses.
+         * ```js
+         * {
+         *   markdown: {
+         *     // Example: Switch to use prism for syntax highlighting in Markdown
+         *     syntaxHighlight: 'prism',
+         *   }
+         * }
+         * ```
          */
-        hostname?: string;
+        syntaxHighlight?: 'shiki' | 'prism' | false;
         /**
          * @docs
-         * @name devOptions.port
-         * @type {number}
-         * @default `3000`
+         * @name markdown.remarkPlugins
+         * @type {Plugin[]}
          * @description
-         * Set which port the dev server should listen on.
+         * Pass a custom [Remark](https://github.com/remarkjs/remark) plugin to customize how your Markdown is built.
+         *
+         * **Note:** Enabling custom `remarkPlugins` or `rehypePlugins` removes Astro's built-in support for [GitHub-flavored Markdown](https://github.github.com/gfm/) support, [Footnotes](https://github.com/remarkjs/remark-footnotes) syntax, [Smartypants](https://github.com/silvenon/remark-smartypants). You must explicitly add these plugins to your `astro.config.mjs` file, if desired.
          *
-         * If the given port is already in use, Astro will automatically try the next available port.
+         * ```js
+         * {
+         *   markdown: {
+         *     // Example: The default set of remark plugins used by Astro
+         *     remarkPlugins: ['remark-code-titles', ['rehype-autolink-headings', { behavior: 'prepend' }]],
+         *   },
+         * };
+         * ```
          */
-        port?: number;
+        remarkPlugins?: Plugin[];
         /**
          * @docs
-         * @name devOptions.trailingSlash
-         * @type {('always' | 'never' | 'ignore')}
-         * @default `'always'`
-         * @see buildOptions.pageUrlFormat
+         * @name markdown.rehypePlugins
+         * @type {Plugin[]}
          * @description
+         * Pass a custom [Rehype](https://github.com/remarkjs/remark-rehype) plugin to customize how your Markdown is built.
          *
-         * Set the route matching behavior of the dev server. Choose from the following options:
-         *   - 'always' - Only match URLs that include a trailing slash (ex: "/foo/")
-         *   - 'never' - Never match URLs that include a trailing slash (ex: "/foo")
-         *   - 'ignore' - Match URLs regardless of whether a trailing "/" exists
-         *
-         * Use this configuration option if your production host has strict handling of how trailing slashes work or do not work.
-         *
-         * You can also set this if you prefer to be more strict yourself, so that URLs with or without trailing slashes won't work during development.
+         * **Note:** Enabling custom `remarkPlugins` or `rehypePlugins` removes Astro's built-in support for [GitHub-flavored Markdown](https://github.github.com/gfm/) support, [Footnotes](https://github.com/remarkjs/remark-footnotes) syntax, [Smartypants](https://github.com/silvenon/remark-smartypants). You must explicitly add these plugins to your `astro.config.mjs` file, if desired.
          *
          * ```js
          * {
-         *   devOptions: {
-         *     // Example: Require a trailing slash during development
-         * 	   trailingSlash: 'always'
-         *   }
-         * }
+         *   markdown: {
+         *     // Example: The default set of rehype plugins used by Astro
+         *     rehypePlugins: [['rehype-toc', { headings: ['h2', 'h3'] }], [addClasses, { 'h1,h2,h3': 'title' }], 'rehype-slug'],
+         *   },
+         * };
          * ```
          */
-        trailingSlash?: 'always' | 'never' | 'ignore';
+        rehypePlugins?: Plugin[];
     };
     /**
-     * Enable experimental support for 3rd-party integrations.
-     * Default: false
+     * @name adapter
+     * @type {AstroIntegration}
+     * @default `undefined`
+     * @description
+     * Add an adapter to build for SSR (server-side rendering). An adapter makes it easy to connect a deployed Astro app to a hosting provider or runtime environment.
      */
-    experimentalIntegrations?: boolean;
+    adapter?: AstroIntegration;
+    /**
+     * @docs
+     * @kind heading
+     * @name Integrations
+     * @description
+     *
+     * Extend Astro with custom integrations. Integrations are your one-stop-shop for adding framework support (like Solid.js), new features (like sitemaps), and new libraries (like Partytown and Turbolinks).
+     *
+     * Read our [Integrations Guide](/en/guides/integrations-guide/) for help getting started with Astro Integrations.
+     *
+     * ```js
+     * import react from '@astrojs/react';
+     * import tailwind from '@astrojs/tailwind';
+     * {
+     *   // Example: Add React + Tailwind support to Astro
+     *   integrations: [react(), tailwind()]
+     * }
+     * ```
+     */
+    integrations?: Array<AstroIntegration | AstroIntegration[]>;
     /**
      * @docs
-     * @name vite
-     * @type {vite.UserConfig}
+     * @kind heading
+     * @name Vite
      * @description
      *
      * Pass additional configuration options to Vite. Useful when Astro doesn't support some advanced configuration that you may need.
@@ -421,9 +443,9 @@ export interface AstroUserConfig {
      * ```js
      * {
      *   vite: {
-     * 	   ssr: {
-     *      // Example: Force a broken package to skip SSR processing, if needed
-     * 		external: ['broken-npm-package'],
+     *     ssr: {
+     *       // Example: Force a broken package to skip SSR processing, if needed
+     *       external: ['broken-npm-package'],
      *     }
      *   }
      * }
@@ -433,7 +455,7 @@ export interface AstroUserConfig {
      * {
      *   vite: {
      *     // Example: Add custom vite plugins directly to your Astro project
-     * 	   plugins: [myPlugin()],
+     *     plugins: [myPlugin()],
      *   }
      * }
      * ```
@@ -441,6 +463,40 @@ export interface AstroUserConfig {
     vite?: vite.UserConfig & {
         ssr?: vite.SSROptions;
     };
+    experimental?: {
+        /**
+         * Enable experimental support for 3rd-party integrations.
+         * Default: false
+         */
+        integrations?: boolean;
+        /**
+         * Enable a build for SSR support.
+         * Default: false
+         */
+        ssr?: boolean;
+    };
+    /** @deprecated - Use "integrations" instead. Run Astro to learn more about migrating. */
+    renderers?: never;
+    /** @deprecated `projectRoot` has been renamed to `root` */
+    projectRoot?: never;
+    /** @deprecated `src` has been renamed to `srcDir` */
+    src?: never;
+    /** @deprecated `pages` has been removed. It is no longer configurable. */
+    pages?: never;
+    /** @deprecated `public` has been renamed to `publicDir` */
+    public?: never;
+    /** @deprecated `dist` has been renamed to `outDir` */
+    dist?: never;
+    /** @deprecated `styleOptions` has been renamed to `style` */
+    styleOptions?: never;
+    /** @deprecated `markdownOptions` has been renamed to `markdown` */
+    markdownOptions?: never;
+    /** @deprecated `buildOptions` has been renamed to `build` */
+    buildOptions?: never;
+    /** @deprecated `devOptions` has been renamed to `server` */
+    devOptions?: never;
+    /** @deprecated `experimentalIntegrations` has been renamed to `experimental: { integrations: true }` */
+    experimentalIntegrations?: never;
 }
 /**
  * IDs for different stages of JS script injection:
@@ -474,19 +530,17 @@ export interface ComponentInstance {
     css?: string[];
     getStaticPaths?: (options: GetStaticPathsOptions) => GetStaticPathsResult;
 }
-/**
- * Astro.fetchContent() result
- * Docs: https://docs.astro.build/reference/api-reference/#astrofetchcontent
- */
-export declare type FetchContentResult<T> = FetchContentResultBase & T;
-export declare type FetchContentResultBase = {
-    astro: {
-        headers: string[];
-        source: string;
-        html: string;
-    };
-    url: string;
-};
+export interface MarkdownInstance<T extends Record<string, any>> {
+    frontmatter: T;
+    file: string;
+    url: string | undefined;
+    Content: AstroComponentFactory;
+    getHeaders(): Promise<{
+        depth: number;
+        slug: string;
+        text: string;
+    }[]>;
+}
 export declare type GetHydrateCallback = () => Promise<(element: Element, innerHTML: string | null) => void>;
 /**
  * getStaticPaths() options
@@ -588,7 +642,7 @@ export interface EndpointOutput<Output extends Body = Body> {
     body: Output;
 }
 export interface EndpointHandler {
-    [method: string]: (params: any, request: AstroRequest) => EndpointOutput | Response;
+    [method: string]: (params: any, request: Request) => EndpointOutput | Response;
 }
 export interface AstroRenderer {
     /** Name of the renderer. */
@@ -636,6 +690,10 @@ export interface AstroIntegration {
         'astro:build:start'?: (options: {
             buildConfig: BuildConfig;
         }) => void | Promise<void>;
+        'astro:build:setup'?: (options: {
+            vite: ViteConfigWithSSR;
+            target: 'client' | 'server';
+        }) => void;
         'astro:build:done'?: (options: {
             pages: {
                 pathname: string;