astro 2.4.5 → 2.5.1

package/astro-jsx.d.ts

@@ -18,12 +18,16 @@ declare namespace astroHTML.JSX {
 		children: {};
 	}
 
-	interface IntrinsicAttributes extends AstroBuiltinProps, AstroBuiltinAttributes {
+	interface IntrinsicAttributes
+		extends AstroBuiltinProps,
+			AstroBuiltinAttributes,
+			AstroClientDirectives {
 		slot?: string;
 		children?: Children;
 	}
 
 	type AstroBuiltinProps = import('./dist/@types/astro.js').AstroBuiltinProps;
+	type AstroClientDirectives = import('./dist/@types/astro.js').AstroClientDirectives;
 	type AstroBuiltinAttributes = import('./dist/@types/astro.js').AstroBuiltinAttributes;
 	type AstroDefineVarsAttribute = import('./dist/@types/astro.js').AstroDefineVarsAttribute;
 	type AstroScriptAttributes = import('./dist/@types/astro.js').AstroScriptAttributes &

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

@@ -29,6 +29,8 @@ export interface AstroBuiltinProps {
     'client:visible'?: boolean;
     'client:only'?: boolean | string;
 }
+export interface AstroClientDirectives {
+}
 export interface AstroBuiltinAttributes {
     'class:list'?: Record<string, boolean> | Record<any, any> | Iterable<string> | Iterable<any> | string;
     'set:html'?: any;
@@ -58,6 +60,7 @@ export interface AstroComponentMetadata {
         value: string;
         namespace?: boolean;
     };
+    astroStaticSlot: true;
 }
 /** The flags supported by the Astro CLI */
 export interface CLIFlags {
@@ -407,6 +410,22 @@ export interface AstroUserConfig {
      * ```
      */
     site?: string;
+    /**
+     * @docs
+     * @name compressHTML
+     * @type {boolean}
+     * @default `false`
+     * @description
+     * This is an option to minify your HTML output and reduce the size of your HTML files. When enabled, Astro removes all whitespace from your HTML, including line breaks, from `.astro` components. This occurs both in development mode and in the final build.
+     * To enable this, set the `compressHTML` flag to `true`.
+     *
+     * ```js
+     * {
+     *   compressHTML: true
+     * }
+     * ```
+     */
+    compressHTML?: boolean;
     /**
      * @docs
      * @name base
@@ -494,7 +513,7 @@ export interface AstroUserConfig {
     /**
      * @docs
      * @name output
-     * @type {('static' | 'server')}
+     * @type {('static' | 'server' | 'hybrid')}
      * @default `'static'`
      * @see adapter
      * @description
@@ -503,6 +522,7 @@ export interface AstroUserConfig {
      *
      * - 'static' - Building a static site to be deploy to any static host.
      * - 'server' - Building an app to be deployed to a host supporting SSR (server-side rendering).
+     * - 'hybrid' - Building a static site with a few server-side rendered pages.
      *
      * ```js
      * import { defineConfig } from 'astro/config';
@@ -512,7 +532,7 @@ export interface AstroUserConfig {
      * })
      * ```
      */
-    output?: 'static' | 'server';
+    output?: 'static' | 'server' | 'hybrid';
     /**
      * @docs
      * @kind heading
@@ -552,14 +572,14 @@ export interface AstroUserConfig {
          * @type {string}
          * @default `'./dist/client'`
          * @description
-         * Controls the output directory of your client-side CSS and JavaScript when `output: 'server'` only.
+         * Controls the output directory of your client-side CSS and JavaScript when `output: 'server'` or `output: 'hybrid'` only.
          * `outDir` controls where the code is built to.
          *
          * This value is relative to the `outDir`.
          *
          * ```js
          * {
-         *   output: 'server',
+         *   output: 'server', // or 'hybrid'
          *   build: {
          *     client: './client'
          *   }
@@ -984,6 +1004,7 @@ export interface AstroUserConfig {
          * @name experimental.inlineStylesheets
          * @type {('always' | 'auto' | 'never')}
          * @default `never`
+         * @version 2.4.0
          * @description
          * Control whether styles are sent to the browser in a separate css file or inlined into `<style>` tags. Choose from the following options:
          *  - `'always'` - all styles are inlined into `<style>` tags
@@ -999,6 +1020,27 @@ export interface AstroUserConfig {
          * ```
          */
         inlineStylesheets?: 'always' | 'auto' | 'never';
+        /**
+         * @docs
+         * @name experimental.customClientDirectives
+         * @type {boolean}
+         * @default `false`
+         * @version 2.5.0
+         * @description
+         * Allow integrations to use the [experimental `addClientDirective` API](/en/reference/integrations-reference/#addclientdirective-option) in the `astro:config:setup` hook
+         * to add custom client directives in Astro files.
+         *
+         * To enable this feature, set `experimental.customClientDirectives` to `true` in your Astro config:
+         *
+         * ```js
+         * {
+         * 	experimental: {
+         *		customClientDirectives: true,
+         * 	},
+         * }
+         * ```
+         */
+        customClientDirectives?: boolean;
         /**
          * @docs
          * @name experimental.middleware
@@ -1019,6 +1061,43 @@ export interface AstroUserConfig {
          * ```
          */
         middleware?: boolean;
+        /**
+         * @docs
+         * @name experimental.hybridOutput
+         * @type {boolean}
+         * @default `false`
+         * @version 2.5.0
+         * @description
+         * Enable experimental support for hybrid SSR with pre-rendering enabled by default.
+         *
+         * To enable this feature, first set `experimental.hybridOutput` to `true` in your Astro config, and set `output` to `hybrid`.
+         *
+         * ```js
+         * {
+         *  output: 'hybrid',
+         * 	experimental: {
+         *		hybridOutput: true,
+         * 	},
+         * }
+         * ```
+         * Then add `export const prerender =  false` to any page or endpoint you want to opt-out of pre-rendering.
+         * ```astro
+         * ---
+         * // pages/contact.astro
+         * export const prerender = false
+         *
+         * if (Astro.request.method === 'POST') {
+         *  // handle form submission
+         * }
+         * ---
+         * <form method="POST">
+         * 	<input type="text" name="name" />
+         * 	<input type="email" name="email" />
+         * 	<button type="submit">Submit</button>
+         * </form>
+         * ```
+         */
+        hybridOutput?: boolean;
     };
     /** @deprecated - Use "integrations" instead. Run Astro to learn more about migrating. */
     renderers?: never;
@@ -1071,19 +1150,28 @@ export type ContentEntryModule = {
         filePath: string;
     };
 };
+export type DataEntryModule = {
+    id: string;
+    collection: string;
+    data: Record<string, unknown>;
+    _internal: {
+        rawData: string;
+        filePath: string;
+    };
+};
 export interface ContentEntryType {
     extensions: string[];
     getEntryInfo(params: {
         fileUrl: URL;
         contents: string;
-    }): GetEntryInfoReturnType | Promise<GetEntryInfoReturnType>;
+    }): GetContentEntryInfoReturnType | Promise<GetContentEntryInfoReturnType>;
     getRenderModule?(this: rollup.PluginContext, params: {
         viteId: string;
         entry: ContentEntryModule;
     }): rollup.LoadResult | Promise<rollup.LoadResult>;
     contentModuleTypes?: string;
 }
-type GetEntryInfoReturnType = {
+type GetContentEntryInfoReturnType = {
     data: Record<string, unknown>;
     /**
      * Used for error hints to point to correct line and location
@@ -1094,17 +1182,33 @@ type GetEntryInfoReturnType = {
     body: string;
     slug: string;
 };
+export interface DataEntryType {
+    extensions: string[];
+    getEntryInfo(params: {
+        fileUrl: URL;
+        contents: string;
+    }): GetDataEntryInfoReturnType | Promise<GetDataEntryInfoReturnType>;
+}
+export type GetDataEntryInfoReturnType = {
+    data: Record<string, unknown>;
+    rawData?: string;
+};
 export interface AstroSettings {
     config: AstroConfig;
     adapter: AstroAdapter | undefined;
     injectedRoutes: InjectedRoute[];
     pageExtensions: string[];
     contentEntryTypes: ContentEntryType[];
+    dataEntryTypes: DataEntryType[];
     renderers: AstroRenderer[];
     scripts: {
         stage: InjectedScriptStage;
         content: string;
     }[];
+    /**
+     * Map of directive name (e.g. `load`) to the directive script code
+     */
+    clientDirectives: Map<string, string>;
     tsConfig: TsConfigJson | undefined;
     tsConfigPath: string | undefined;
     watchFiles: string[];
@@ -1466,6 +1570,7 @@ export interface SSRLoadedRenderer extends AstroRenderer {
             html: string;
             attrs?: Record<string, string>;
         }>;
+        supportsAstroStaticSlot?: boolean;
     };
 }
 export type HookParameters<Hook extends keyof AstroIntegration['hooks'], Fn = AstroIntegration['hooks'][Hook]> = Fn extends (...args: any) => any ? Parameters<Fn>[0] : never;
@@ -1483,6 +1588,7 @@ export interface AstroIntegration {
             addWatchFile: (path: URL | string) => void;
             injectScript: (stage: InjectedScriptStage, content: string) => void;
             injectRoute: (injectRoute: InjectedRoute) => void;
+            addClientDirective: (directive: ClientDirectiveConfig) => void;
         }) => void | Promise<void>;
         'astro:config:done'?: (options: {
             config: AstroConfig;
@@ -1567,6 +1673,7 @@ export interface SSRMetadata {
     hasDirectives: Set<string>;
     hasRenderedHead: boolean;
     headInTree: boolean;
+    clientDirectives: Map<string, string>;
 }
 /**
  * A hint on whether the Astro runtime needs to wait on a component to render head
@@ -1615,3 +1722,20 @@ export type CreatePreviewServer = (params: PreviewServerParams) => PreviewServer
 export interface PreviewModule {
     default: CreatePreviewServer;
 }
+type DirectiveHydrate = () => Promise<void>;
+type DirectiveLoad = () => Promise<DirectiveHydrate>;
+type DirectiveOptions = {
+    /**
+     * The component displayName
+     */
+    name: string;
+    /**
+     * The attribute value provided
+     */
+    value: string;
+};
+export type ClientDirective = (load: DirectiveLoad, options: DirectiveOptions, el: HTMLElement) => void;
+export interface ClientDirectiveConfig {
+    name: string;
+    entrypoint: string;
+}

package/dist/assets/generate.d.ts

@@ -0,0 +1,22 @@
+import type { StaticBuildOptions } from '../core/build/types.js';
+import type { ImageTransform } from './types.js';
+interface GenerationDataUncached {
+    cached: false;
+    weight: {
+        before: number;
+        after: number;
+    };
+}
+interface GenerationDataCached {
+    cached: true;
+}
+type GenerationData = GenerationDataUncached | GenerationDataCached;
+export declare function generateImage(buildOpts: StaticBuildOptions, options: ImageTransform, filepath: string): Promise<GenerationData | undefined>;
+export declare function getStaticImageList(): Iterable<[
+    string,
+    {
+        path: string;
+        options: ImageTransform;
+    }
+]>;
+export {};

package/dist/assets/generate.js

@@ -0,0 +1,90 @@
+import fs from "node:fs";
+import { basename, join } from "node:path/posix";
+import { warn } from "../core/logger/core.js";
+import { prependForwardSlash } from "../core/path.js";
+import { isHybridOutput } from "../prerender/utils.js";
+import { getConfiguredImageService, isESMImportedImage } from "./internal.js";
+async function generateImage(buildOpts, options, filepath) {
+  if (!isESMImportedImage(options.src)) {
+    return void 0;
+  }
+  let useCache = true;
+  const assetsCacheDir = new URL("assets/", buildOpts.settings.config.cacheDir);
+  try {
+    await fs.promises.mkdir(assetsCacheDir, { recursive: true });
+  } catch (err) {
+    warn(
+      buildOpts.logging,
+      "astro:assets",
+      `An error was encountered while creating the cache directory. Proceeding without caching. Error: ${err}`
+    );
+    useCache = false;
+  }
+  let serverRoot, clientRoot;
+  if (buildOpts.settings.config.output === "server" || isHybridOutput(buildOpts.settings.config)) {
+    serverRoot = buildOpts.settings.config.build.server;
+    clientRoot = buildOpts.settings.config.build.client;
+  } else {
+    serverRoot = buildOpts.settings.config.outDir;
+    clientRoot = buildOpts.settings.config.outDir;
+  }
+  const finalFileURL = new URL("." + filepath, clientRoot);
+  const finalFolderURL = new URL("./", finalFileURL);
+  const cachedFileURL = new URL(basename(filepath), assetsCacheDir);
+  try {
+    await fs.promises.copyFile(cachedFileURL, finalFileURL);
+    return {
+      cached: true
+    };
+  } catch (e) {
+  }
+  const originalImagePath = options.src.src;
+  const fileData = await fs.promises.readFile(
+    new URL(
+      "." + prependForwardSlash(
+        join(buildOpts.settings.config.build.assets, basename(originalImagePath))
+      ),
+      serverRoot
+    )
+  );
+  const imageService = await getConfiguredImageService();
+  const resultData = await imageService.transform(
+    fileData,
+    { ...options, src: originalImagePath },
+    buildOpts.settings.config.image.service.config
+  );
+  await fs.promises.mkdir(finalFolderURL, { recursive: true });
+  if (useCache) {
+    try {
+      await fs.promises.writeFile(cachedFileURL, resultData.data);
+      await fs.promises.copyFile(cachedFileURL, finalFileURL);
+    } catch (e) {
+      warn(
+        buildOpts.logging,
+        "astro:assets",
+        `An error was encountered while creating the cache directory. Proceeding without caching. Error: ${e}`
+      );
+      await fs.promises.writeFile(finalFileURL, resultData.data);
+    }
+  } else {
+    await fs.promises.writeFile(finalFileURL, resultData.data);
+  }
+  return {
+    cached: false,
+    weight: {
+      before: Math.trunc(fileData.byteLength / 1024),
+      after: Math.trunc(resultData.data.byteLength / 1024)
+    }
+  };
+}
+function getStaticImageList() {
+  var _a, _b;
+  if (!((_a = globalThis == null ? void 0 : globalThis.astroAsset) == null ? void 0 : _a.staticImages)) {
+    return [];
+  }
+  return (_b = globalThis.astroAsset.staticImages) == null ? void 0 : _b.entries();
+}
+export {
+  generateImage,
+  getStaticImageList
+};

package/dist/assets/internal.d.ts

@@ -1,26 +1,5 @@
-import type { StaticBuildOptions } from '../core/build/types.js';
 import { type ImageService } from './services/service.js';
 import type { GetImageResult, ImageMetadata, ImageTransform } from './types.js';
 export declare function isESMImportedImage(src: ImageMetadata | string): src is ImageMetadata;
 export declare function getConfiguredImageService(): Promise<ImageService>;
 export declare function getImage(options: ImageTransform, serviceConfig: Record<string, any>): Promise<GetImageResult>;
-export declare function getStaticImageList(): Iterable<[
-    string,
-    {
-        path: string;
-        options: ImageTransform;
-    }
-]>;
-interface GenerationDataUncached {
-    cached: false;
-    weight: {
-        before: number;
-        after: number;
-    };
-}
-interface GenerationDataCached {
-    cached: true;
-}
-type GenerationData = GenerationDataUncached | GenerationDataCached;
-export declare function generateImage(buildOpts: StaticBuildOptions, options: ImageTransform, filepath: string): Promise<GenerationData | undefined>;
-export {};

package/dist/assets/internal.js

@@ -1,8 +1,4 @@
-import fs from "node:fs";
-import { basename, join } from "node:path/posix";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
-import { warn } from "../core/logger/core.js";
-import { prependForwardSlash } from "../core/path.js";
 import { isLocalService } from "./services/service.js";
 function isESMImportedImage(src) {
   return typeof src === "object";
@@ -45,90 +41,8 @@ async function getImage(options, serviceConfig) {
     attributes: service.getHTMLAttributes !== void 0 ? service.getHTMLAttributes(validatedOptions, serviceConfig) : {}
   };
 }
-function getStaticImageList() {
-  var _a, _b;
-  if (!((_a = globalThis == null ? void 0 : globalThis.astroAsset) == null ? void 0 : _a.staticImages)) {
-    return [];
-  }
-  return (_b = globalThis.astroAsset.staticImages) == null ? void 0 : _b.entries();
-}
-async function generateImage(buildOpts, options, filepath) {
-  if (!isESMImportedImage(options.src)) {
-    return void 0;
-  }
-  let useCache = true;
-  const assetsCacheDir = new URL("assets/", buildOpts.settings.config.cacheDir);
-  try {
-    await fs.promises.mkdir(assetsCacheDir, { recursive: true });
-  } catch (err) {
-    warn(
-      buildOpts.logging,
-      "astro:assets",
-      `An error was encountered while creating the cache directory. Proceeding without caching. Error: ${err}`
-    );
-    useCache = false;
-  }
-  let serverRoot, clientRoot;
-  if (buildOpts.settings.config.output === "server") {
-    serverRoot = buildOpts.settings.config.build.server;
-    clientRoot = buildOpts.settings.config.build.client;
-  } else {
-    serverRoot = buildOpts.settings.config.outDir;
-    clientRoot = buildOpts.settings.config.outDir;
-  }
-  const finalFileURL = new URL("." + filepath, clientRoot);
-  const finalFolderURL = new URL("./", finalFileURL);
-  const cachedFileURL = new URL(basename(filepath), assetsCacheDir);
-  try {
-    await fs.promises.copyFile(cachedFileURL, finalFileURL);
-    return {
-      cached: true
-    };
-  } catch (e) {
-  }
-  const originalImagePath = options.src.src;
-  const fileData = await fs.promises.readFile(
-    new URL(
-      "." + prependForwardSlash(
-        join(buildOpts.settings.config.build.assets, basename(originalImagePath))
-      ),
-      serverRoot
-    )
-  );
-  const imageService = await getConfiguredImageService();
-  const resultData = await imageService.transform(
-    fileData,
-    { ...options, src: originalImagePath },
-    buildOpts.settings.config.image.service.config
-  );
-  await fs.promises.mkdir(finalFolderURL, { recursive: true });
-  if (useCache) {
-    try {
-      await fs.promises.writeFile(cachedFileURL, resultData.data);
-      await fs.promises.copyFile(cachedFileURL, finalFileURL);
-    } catch (e) {
-      warn(
-        buildOpts.logging,
-        "astro:assets",
-        `An error was encountered while creating the cache directory. Proceeding without caching. Error: ${e}`
-      );
-      await fs.promises.writeFile(finalFileURL, resultData.data);
-    }
-  } else {
-    await fs.promises.writeFile(finalFileURL, resultData.data);
-  }
-  return {
-    cached: false,
-    weight: {
-      before: Math.trunc(fileData.byteLength / 1024),
-      after: Math.trunc(resultData.data.byteLength / 1024)
-    }
-  };
-}
 export {
-  generateImage,
   getConfiguredImageService,
   getImage,
-  getStaticImageList,
   isESMImportedImage
 };

package/dist/assets/vite-plugin-assets.js

@@ -20,6 +20,8 @@ import { imageMetadata } from "./utils/metadata.js";
 import { getOrigQueryParams } from "./utils/queryParams.js";
 import { hashTransform, propsToFilename } from "./utils/transformToPath.js";
 const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
+const rawRE = /(?:\?|&)raw(?:&|$)/;
+const urlRE = /(\?|&)url(?:&|$)/;
 function assets({
   settings,
   logging,
@@ -189,6 +191,9 @@ function assets({
         resolvedConfig = viteConfig;
       },
       async load(id) {
+        if (rawRE.test(id) || urlRE.test(id)) {
+          return;
+        }
         const cleanedUrl = removeQueryString(id);
         if (/\.(jpeg|jpg|png|tiff|webp|gif|svg)$/.test(cleanedUrl)) {
           const meta = await emitESMImage(id, this.meta.watchMode, this.emitFile, settings);

package/dist/content/consts.d.ts

@@ -1,5 +1,7 @@
 export declare const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
-export declare const CONTENT_FLAG = "astroContent";
+export declare const CONTENT_FLAG = "astroContentCollectionEntry";
+export declare const DATA_FLAG = "astroDataCollectionEntry";
+export declare const CONTENT_FLAGS: readonly ["astroContentCollectionEntry", "astroDataCollectionEntry", "astroPropagatedAssets"];
 export declare const VIRTUAL_MODULE_ID = "astro:content";
 export declare const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
 export declare const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";

package/dist/content/consts.js

@@ -1,5 +1,7 @@
 const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
-const CONTENT_FLAG = "astroContent";
+const CONTENT_FLAG = "astroContentCollectionEntry";
+const DATA_FLAG = "astroDataCollectionEntry";
+const CONTENT_FLAGS = [CONTENT_FLAG, DATA_FLAG, PROPAGATED_ASSET_FLAG];
 const VIRTUAL_MODULE_ID = "astro:content";
 const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
 const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
@@ -7,7 +9,9 @@ const SCRIPTS_PLACEHOLDER = "@@ASTRO-SCRIPTS@@";
 const CONTENT_TYPES_FILE = "types.d.ts";
 export {
   CONTENT_FLAG,
+  CONTENT_FLAGS,
   CONTENT_TYPES_FILE,
+  DATA_FLAG,
   LINKS_PLACEHOLDER,
   PROPAGATED_ASSET_FLAG,
   SCRIPTS_PLACEHOLDER,

package/dist/content/runtime-assets.d.ts

@@ -1,4 +1,4 @@
 import type { PluginContext } from 'rollup';
 import { z } from 'zod';
 import type { AstroSettings } from '../@types/astro.js';
-export declare function createImage(settings: AstroSettings, pluginContext: PluginContext, entryFilePath: string): () => z.ZodEffects<z.ZodString, import("../assets/utils/metadata.js").Metadata | z.ZodNever, string>;
+export declare function createImage(settings: Pick<AstroSettings, 'config'>, pluginContext: PluginContext, entryFilePath: string): () => z.ZodEffects<z.ZodString, import("../assets/utils/metadata.js").Metadata | z.ZodNever, string>;

package/dist/content/runtime.d.ts

@@ -1,3 +1,6 @@
+import type { MarkdownHeading } from '@astrojs/markdown-remark';
+import { type AstroComponentFactory } from '../runtime/server/index.js';
+import type { ContentLookupMap } from './utils.js';
 type LazyImport = () => Promise<any>;
 type GlobResult = Record<string, LazyImport>;
 type CollectionToEntryMap = Record<string, GlobResult>;
@@ -6,8 +9,9 @@ export declare function createCollectionToGlobResultMap({ globResult, contentDir
     globResult: GlobResult;
     contentDir: string;
 }): CollectionToEntryMap;
-export declare function createGetCollection({ collectionToEntryMap, getRenderEntryImport, }: {
-    collectionToEntryMap: CollectionToEntryMap;
+export declare function createGetCollection({ contentCollectionToEntryMap, dataCollectionToEntryMap, getRenderEntryImport, }: {
+    contentCollectionToEntryMap: CollectionToEntryMap;
+    dataCollectionToEntryMap: CollectionToEntryMap;
     getRenderEntryImport: GetEntryImport;
 }): (collection: string, filter?: ((entry: any) => unknown) | undefined) => Promise<any[]>;
 export declare function createGetEntryBySlug({ getEntryImport, getRenderEntryImport, }: {
@@ -19,10 +23,60 @@ export declare function createGetEntryBySlug({ getEntryImport, getRenderEntryImp
     body: any;
     collection: any;
     data: any;
-    render(): Promise<{
-        Content: import("../runtime/server/index.js").AstroComponentFactory;
-        headings: any;
-        remarkPluginFrontmatter: any;
-    }>;
+    render(): Promise<RenderResult>;
 } | undefined>;
+export declare function createGetDataEntryById({ dataCollectionToEntryMap, }: {
+    dataCollectionToEntryMap: CollectionToEntryMap;
+}): (collection: string, id: string) => Promise<{
+    id: any;
+    collection: any;
+    data: any;
+}>;
+type ContentEntryResult = {
+    id: string;
+    slug: string;
+    body: string;
+    collection: string;
+    data: Record<string, any>;
+    render(): Promise<RenderResult>;
+};
+type DataEntryResult = {
+    id: string;
+    collection: string;
+    data: Record<string, any>;
+};
+type EntryLookupObject = {
+    collection: string;
+    id: string;
+} | {
+    collection: string;
+    slug: string;
+};
+export declare function createGetEntry({ getEntryImport, getRenderEntryImport, }: {
+    getEntryImport: GetEntryImport;
+    getRenderEntryImport: GetEntryImport;
+}): (collectionOrLookupObject: string | EntryLookupObject, _lookupId?: string) => Promise<ContentEntryResult | DataEntryResult | undefined>;
+export declare function createGetEntries(getEntry: ReturnType<typeof createGetEntry>): (entries: {
+    collection: string;
+    id: string;
+}[] | {
+    collection: string;
+    slug: string;
+}[]) => Promise<(ContentEntryResult | DataEntryResult | undefined)[]>;
+type RenderResult = {
+    Content: AstroComponentFactory;
+    headings: MarkdownHeading[];
+    remarkPluginFrontmatter: Record<string, any>;
+};
+export declare function createReference({ lookupMap }: {
+    lookupMap: ContentLookupMap;
+}): (collection: string) => import("zod").ZodEffects<import("zod").ZodString, {
+    slug: string;
+    collection: string;
+    id?: undefined;
+} | {
+    id: string;
+    collection: string;
+    slug?: undefined;
+} | undefined, string>;
 export {};