camox 0.43.0 → 0.45.0

package/dist/core/createCollection.d.ts

@@ -0,0 +1,55 @@
+import { LayoutRequestContext } from "./requestContext.js";
+import { LayoutCollectionItemResult, LayoutRoutesResult, RecordPages } from "./createLayout.js";
+import { CollectionFieldBuilder, StringField } from "./lib/contentType.js";
+import { SystemOrderKey } from "@camox/api-contract";
+import { Static, TObject, TSchema } from "@sinclair/typebox";
+//#region src/core/createCollection.d.ts
+/** Record metadata names, reserved so query `orderBy` keys stay unambiguous. */
+type ReservedFieldNames = { [K in SystemOrderKey]?: never; };
+type TextKey<T extends Record<string, TSchema>> = { [K in keyof T & string]: T[K] extends {
+  fieldType: "String";
+} ? K : never; }[keyof T & string];
+/**
+ * A definition only: record authoring and querying are not public SDK APIs.
+ * `label` is checked against `content`'s return type: typing it against `T` directly would fix
+ * `T` before the `content` callback is inferred.
+ */
+export declare function createCollection<const T extends Record<string, TSchema> & ReservedFieldNames, const L extends string>(options: {
+  id: string;
+  title: string;
+  description: string;
+  content: (field: CollectionFieldBuilder) => T & Record<NoInfer<L>, StringField>;
+  label: L;
+}): Collection<T>;
+/** The pages of a derived layout, one per record, found by the record's `by` field. */
+export interface CollectionPages<T extends Record<string, TSchema>, Param extends string> {
+  loader: (input: {
+    params: { [K in Param]: string; };
+    context: LayoutRequestContext;
+  }) => Promise<LayoutCollectionItemResult<Static<TObject<T>>, string, T>>;
+  routes: (input: {
+    context: LayoutRequestContext;
+  }) => Promise<LayoutRoutesResult<{ [K in Param]: string; }>>;
+  /** Synced to the API, which checks no two records share the value pages are found by. */
+  recordPages: RecordPages;
+}
+/** The default erases the schema for heterogeneous app registries. */
+export type Collection<T extends Record<string, TSchema> = any> = {
+  /**
+   * A record page's `loader` and `routes`, to spread into a derived layout whose route has
+   * `param`. Each page renders the record whose String field `by` equals the param.
+   */
+  pages: <const Param extends string>(options: {
+    by: TextKey<T>;
+    param: Param;
+  }) => CollectionPages<T, Param>;
+  _internal: {
+    id: string;
+    title: string;
+    description: string;
+    label: TextKey<T>;
+    contentSchema: TObject<T>;
+  };
+};
+//#endregion
+export type { CollectionFieldBuilder };

package/dist/core/createCollection.js

@@ -0,0 +1,93 @@
+import { collectionFieldBuilder } from "./lib/contentType.js";
+import { notFound } from "./notFound.js";
+import { getRecordLookup } from "./requestContext.js";
+import { SYSTEM_ORDER_KEYS } from "@camox/api-contract";
+import { Type } from "@sinclair/typebox";
+
+//#region src/core/createCollection.ts
+/**
+* A definition only: record authoring and querying are not public SDK APIs.
+* `label` is checked against `content`'s return type: typing it against `T` directly would fix
+* `T` before the `content` callback is inferred.
+*/
+function createCollection(options) {
+	if (!options.id.trim()) throw new Error("Collection id is required");
+	const content = options.content(collectionFieldBuilder);
+	for (const key of SYSTEM_ORDER_KEYS) if (Object.hasOwn(content, key)) throw new Error(`Collection "${options.id}" field "${key}": reserved field name`);
+	const supported = /* @__PURE__ */ new Set([
+		"String",
+		"Boolean",
+		"Enum",
+		"Embed",
+		"Image",
+		"File",
+		"ImageList",
+		"FileList",
+		"Reference",
+		"ReferenceList"
+	]);
+	for (const [key, field] of Object.entries(content)) if (!supported.has(field.fieldType)) throw new Error(`Collection "${options.id}" field "${key}": ${String(field.fieldType)} storage is not supported yet`);
+	if (content[options.label]?.fieldType !== "String") throw new Error("Collection label must name a String field");
+	const id = options.id;
+	return {
+		pages({ by, param }) {
+			const ambiguousValue = (ids, value) => /* @__PURE__ */ new Error(`Collection "${id}": records ${ids.join(", ")} all have ${by} "${value}"`);
+			return {
+				async loader({ params, context }) {
+					const value = params[param];
+					if (!value || value.includes("/")) throw notFound();
+					const records = await getRecordLookup(context).findByField({
+						collectionId: id,
+						field: by,
+						value
+					});
+					if (records.length > 1) throw ambiguousValue(records.map((record) => record.id), value);
+					const [record] = records;
+					if (!record) throw notFound();
+					return {
+						kind: "collection-item",
+						collectionId: id,
+						data: {
+							id: record.id,
+							content: record.content,
+							...record.references && { references: record.references },
+							...record.updatedAt != null && { updatedAt: record.updatedAt }
+						}
+					};
+				},
+				async routes({ context }) {
+					const records = await getRecordLookup(context).listPageValues({
+						collectionId: id,
+						field: by
+					});
+					const idsByValue = /* @__PURE__ */ new Map();
+					for (const record of records) idsByValue.set(record.value, [...idsByValue.get(record.value) ?? [], record.id]);
+					for (const [value, ids] of idsByValue) if (ids.length > 1) throw ambiguousValue(ids, value);
+					return { data: records.map((record) => ({
+						params: { [param]: record.value },
+						target: {
+							kind: "collection-item",
+							collectionId: id,
+							id: record.id,
+							label: record.label
+						}
+					})) };
+				},
+				recordPages: {
+					collectionId: id,
+					field: by
+				}
+			};
+		},
+		_internal: {
+			id,
+			title: options.title,
+			description: options.description,
+			label: options.label,
+			contentSchema: Type.Object(content, { additionalProperties: false })
+		}
+	};
+}
+
+//#endregion
+export { createCollection };

package/dist/core/createLayout.d.ts

@@ -1,14 +1,17 @@
+import { ReferenceScope } from "./lib/reference.js";
+import { CollectionRecordId, LayoutRequestContext, LoadedRecord } from "./requestContext.js";
+import { notFound } from "./notFound.js";
+import { ContentProxy } from "./lib/contentType.js";
 import * as React from "react";
-import * as _$react_jsx_runtime0 from "react/jsx-runtime";
-
+import { TSchema } from "@sinclair/typebox";
 //#region src/core/createLayout.d.ts
-interface OgImageParams {
+export interface OgImageParams {
   title: string;
   description: string;
   projectName: string;
 }
-interface LayoutBlockData {
-  _id: number;
+export interface LayoutBlockData {
+  _id: string;
   type: string;
   content: Record<string, unknown>;
   settings?: Record<string, unknown>;
@@ -47,54 +50,181 @@ interface LayoutBlock<TLayoutOnly extends boolean = boolean> {
  *   `Type 'X' is not assignable to type '❌ Camox: ...'`
  * instead of the unreadable structural diff on the full Block shape.
  */
-type ValidateLayoutOnlyBlocks<T extends readonly LayoutBlock[]> = { [K in keyof T]: T[K] extends LayoutBlock<true> ? T[K] : "❌ Camox: blocks in `blocks.before` and `blocks.after` must be defined with `layoutOnly: true`. Add `layoutOnly: true` to this block's `createBlock` options." };
-type ValidatePageContentBlocks<T extends readonly LayoutBlock[]> = { [K in keyof T]: T[K] extends LayoutBlock<true> ? "❌ Camox: blocks in `blocks.initial` must NOT be `layoutOnly: true` — `initial` is for page-content blocks. Remove `layoutOnly: true` from this block's `createBlock` options." : T[K] };
-interface CreateLayoutOptions<TBefore extends readonly LayoutBlock[], TAfter extends readonly LayoutBlock[], TInitial extends readonly LayoutBlock[]> {
+type ValidateLayoutOnlyBlocks<T extends readonly LayoutBlock[]> = { [K in keyof T]: T[K] extends LayoutBlock<true> ? T[K] : "❌ Camox: blocks in `blocks.before` and `blocks.after` must be defined with `layoutOnly: true`. Add `layoutOnly: true` to this block's `createBlock` options."; };
+/**
+ * A block module, imported only when Camox seeds the initial page. A static import would put
+ * the block in every visitor's bundle, since layouts load on every page.
+ */
+type InitialBlockImport = () => Promise<{
+  block: LayoutBlock;
+}>;
+declare const INITIAL_LAYOUT_ONLY_ERROR = "❌ Camox: blocks in `blocks.initial` must NOT be `layoutOnly: true` — `initial` is for page-content blocks. Remove `layoutOnly: true` from this block's `createBlock` options.";
+type ValidatePageContentBlocks<T extends readonly InitialBlockImport[]> = { [K in keyof T]: Awaited<ReturnType<T[K]>>["block"] extends LayoutBlock<true> ? typeof INITIAL_LAYOUT_ONLY_ERROR : T[K]; };
+/** Successful ordinary loader result. Data must be JSON-serializable. */
+export interface LayoutLoaderResult<Data = unknown> {
+  kind: "data";
+  data: Data;
+}
+declare const collectionFields: unique symbol;
+/**
+ * A loader result rendering one collection record, as `collection.pages()` returns it. Wrappers
+ * keep the page bound to its record by returning it unchanged.
+ */
+export interface LayoutCollectionItemResult<Content = Record<string, unknown>, CollectionId extends string = string, Fields extends Record<string, TSchema> = any> {
+  kind: "collection-item";
+  collectionId: CollectionId;
+  data: LoadedRecord<Content>;
+  /**
+   * Type only, never set: the collection's fields, which type `layout.Item`. Invariant, so that
+   * records of two collections never merge into one.
+   */
+  readonly [collectionFields]?: (fields: Fields) => Fields;
+}
+/**
+ * What `loader` receives: the page's params, the request context to pass through, and the
+ * page's locale.
+ */
+export interface LayoutLoaderContext<Params = Record<string, string>> {
+  params: Params;
+  context: LayoutRequestContext;
+  /**
+   * The tag of the locale the page renders in, such as `de`, to fetch localized data with when
+   * its source has it. Camox renders the data as returned and never translates it.
+   */
+  locale: string;
+}
+/** What `routes` receives: the request context to pass through. */
+export interface LayoutRoutesContext {
+  context: LayoutRequestContext;
+}
+/** Every successful loader result, before `useData` unwraps it. */
+export type AnyLayoutLoaderResult = LayoutLoaderResult | LayoutCollectionItemResult;
+type LoaderReturn = AnyLayoutLoaderResult | PromiseLike<AnyLayoutLoaderResult>;
+/** The record a discovered page renders, independent of its current params. */
+export interface LayoutRouteTarget extends CollectionRecordId {
+  kind: "collection-item";
+  /** The record's Label, which names its page where pages are listed (llms.txt). */
+  label?: string;
+}
+/** Route discovery result: the params of each page a derived layout can render. */
+export interface LayoutRoutesResult<Params = Record<string, string>> {
+  data: ReadonlyArray<{
+    params: Params;
+    target?: LayoutRouteTarget;
+  }>;
+}
+type RoutesReturn<Params> = LayoutRoutesResult<Params> | PromiseLike<LayoutRoutesResult<Params>>;
+type LoaderData<Result extends LoaderReturn> = [Result] extends [never] ? undefined : Awaited<Result>["data"];
+type ResultFields<R> = R extends LayoutCollectionItemResult<any, any, infer F> ? F : never;
+type IsUnion<T, U = T> = T extends unknown ? ([U] extends [T] ? false : true) : never;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * The fields of the one collection whose records every loader result renders. `never` for
+ * external data, mixed results, several collections, or an envelope typed without its fields.
+ */
+type RecordFields<Result> = [Awaited<Result>] extends [never] ? never : [Awaited<Result>] extends [LayoutCollectionItemResult<any, any, any>] ? true extends IsUnion<ResultFields<Awaited<Result>>> ? never : IsAny<ResultFields<Awaited<Result>>> extends true ? never : ResultFields<Awaited<Result>> : never;
+type StringFieldKeys<F> = { [K in keyof F & string]: F[K] extends {
+  fieldType: "String";
+} ? K : never; }[keyof F & string];
+/** Record pages' meta callbacks also get the record's String fields as plain text. */
+type MetaItem<F> = [F] extends [never] ? {} : {
+  item: { [K in StringFieldKeys<F>]: string; };
+};
+/** Record pages' `toMarkdown` also gets `item`, the reference-list Markdown builder. */
+type MarkdownItem<F> = [F] extends [never] ? {} : F extends Record<string, TSchema> ? {
+  item: ContentProxy<F>;
+} : {};
+/** `layout.Item` exists only on layouts whose loader renders records of one collection. */
+type ItemScope<F> = [F] extends [never] ? {} : F extends Record<string, TSchema> ? {
+  /** The page's record, read-only, with typed fields and the records it links. */
+  Item: (props: {
+    children: (item: ReferenceScope<F>) => React.ReactNode;
+  }) => React.ReactNode;
+} : {};
+/** What a page's metadata callbacks know about it. Curated pages have no loader data or params. */
+export interface PageMetaContext<Data = unknown, Params = Record<string, string>> {
+  projectName: string;
+  pageFullPath: string;
+  data: Data;
+  params: Params;
+}
+/** On singleton and derived pages, `pageMetaTitle` is the layout's `title`. */
+type BuildMetaTitle<Data, Params, F = never> = (params: PageMetaContext<Data, Params> & {
+  pageMetaTitle: string;
+} & MetaItem<F>) => string;
+/** Without it, curated pages use the editor's description and other pages have none. */
+type BuildMetaDescription<Data, Params, F = never> = (params: PageMetaContext<Data, Params> & {
+  pageMetaDescription: string | undefined;
+} & MetaItem<F>) => string | undefined;
+/** The Markdown Representation of a code-owned page, between its layout blocks. */
+type LayoutToMarkdown<Data, Params, F = never> = (context: {
+  data: Data;
+  params: Params;
+} & MarkdownItem<F>) => readonly string[];
+/** The collection a layout's record pages render, and the field each record is found by. */
+export type RecordPages = {
+  collectionId: string;
+  field: string;
+};
+interface CreateLayoutOptions<TBefore extends readonly LayoutBlock[], TAfter extends readonly LayoutBlock[], TInitial extends readonly InitialBlockImport[], Result extends LoaderReturn = LoaderReturn> {
   id: string;
   kind?: "curated" | "derived" | "singleton";
-  loader?: (context: {
-    params: Record<string, string>;
-  }) => unknown;
+  loader?: (context: LayoutLoaderContext) => Result;
+  /** Lists the pages of a derived layout, for the sitemap and the Canvas. */
+  routes?: (context: LayoutRoutesContext) => RoutesReturn<Record<string, string>>;
+  /** A derived layout's record pages, set by spreading `collection.pages(...)`. */
+  recordPages?: RecordPages;
   title: string;
   description: string;
   blocks: {
     before: ValidateLayoutOnlyBlocks<TBefore>;
-    after: ValidateLayoutOnlyBlocks<TAfter>; /** Ordered list of blocks to create on the initial page when a project is first set up. */
+    after: ValidateLayoutOnlyBlocks<TAfter>;
+    /**
+     * Ordered list of blocks to create on the initial page when a project is first set up, as
+     * imports of their modules: `[() => import("../blocks/hero")]`.
+     */
     initial?: ValidatePageContentBlocks<TInitial>;
   };
   component: React.ComponentType<{
     children: React.ReactNode;
   }>;
-  buildMetaTitle: (params: {
-    pageMetaTitle: string;
-    projectName: string;
-    pageFullPath: string;
-  }) => string;
+  buildMetaTitle: BuildMetaTitle<LoaderData<Result>, Record<string, string>, RecordFields<Result>>;
+  buildMetaDescription?: BuildMetaDescription<LoaderData<Result>, Record<string, string>, RecordFields<Result>>;
+  /** Singleton and derived layouts only. */
+  toMarkdown?: LayoutToMarkdown<LoaderData<Result>, Record<string, string>, RecordFields<Result>>;
   buildOgImage?: (params: OgImageParams) => React.ReactElement;
 }
-declare function createLayoutDefinition<const TBefore extends readonly LayoutBlock[], const TAfter extends readonly LayoutBlock[], const TInitial extends readonly LayoutBlock[] = []>(options: CreateLayoutOptions<TBefore, TAfter, TInitial>): {
+declare function createLayoutDefinition<const TBefore extends readonly LayoutBlock[], const TAfter extends readonly LayoutBlock[], const TInitial extends readonly InitialBlockImport[] = []>(options: CreateLayoutOptions<TBefore, TAfter, TInitial>): {
   BeforeBlocks: {
-    (): _$react_jsx_runtime0.JSX.Element;
+    (): React.JSX.Element;
     displayName: string;
   };
   AfterBlocks: {
-    (): _$react_jsx_runtime0.JSX.Element;
+    (): React.JSX.Element;
+    displayName: string;
+  };
+  Item: {
+    ({ children }: {
+      children: (item: any) => React.ReactNode;
+    }): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
     displayName: string;
   };
   useData(): unknown;
   _internal: {
     id: string;
     kind: "curated" | "derived" | "singleton";
-    loader: ((context: {
-      params: Record<string, string>;
-    }) => unknown) | undefined;
+    loader: ((context: LayoutLoaderContext) => LoaderReturn) | undefined;
+    routes: ((context: LayoutRoutesContext) => RoutesReturn<Record<string, string>>) | undefined;
+    recordPages: RecordPages | undefined;
     title: string;
     description: string;
-    buildMetaTitle: (params: {
-      pageMetaTitle: string;
-      projectName: string;
-      pageFullPath: string;
-    }) => string;
+    buildMetaTitle: BuildMetaTitle<unknown, unknown>;
+    buildMetaDescription: BuildMetaDescription<unknown, unknown> | undefined;
+    toMarkdown: ((context: {
+      data: unknown;
+      params: unknown;
+      item?: unknown;
+    }) => readonly string[]) | undefined;
     buildOgImage: ((params: OgImageParams) => Promise<Response>) | undefined;
     blockDefinitions: ({
       type: string;
@@ -107,7 +237,7 @@ declare function createLayoutDefinition<const TBefore extends readonly LayoutBlo
         content: Record<string, unknown>;
         position: string;
       }[];
-      placement: "before";
+      slot: "before";
     } | {
       type: string;
       content: Record<string, unknown>;
@@ -119,9 +249,9 @@ declare function createLayoutDefinition<const TBefore extends readonly LayoutBlo
         content: Record<string, unknown>;
         position: string;
       }[];
-      placement: "after";
+      slot: "after";
     })[];
-    initialBlockBundles: {
+    loadInitialBlockBundles: (() => Promise<{
       type: string;
       content: Record<string, unknown>;
       settings: Record<string, unknown>;
@@ -132,30 +262,39 @@ declare function createLayoutDefinition<const TBefore extends readonly LayoutBlo
         content: Record<string, unknown>;
         position: string;
       }[];
-    }[] | undefined;
+    }[]>) | undefined;
     component: React.ComponentType<{
       children: React.ReactNode;
     }>;
-    Provider: ({
-      layoutBlocks,
-      children,
-      data
-    }: {
+    Provider: ({ layoutBlocks, children, result }: {
       layoutBlocks: Record<string, LayoutBlockData>;
       children: React.ReactNode;
-      data?: unknown;
-    }) => _$react_jsx_runtime0.JSX.Element;
+      result?: AnyLayoutLoaderResult;
+    }) => React.JSX.Element;
   };
 };
-type Layout = ReturnType<typeof createLayoutDefinition>;
-interface LayoutFileRoutes {}
-type Params<Id extends string> = Id extends `${infer Head}.${infer Tail}` ? Params<Head> & Params<Tail> : Id extends `$${infer Name}` ? { [K in Name]: string } : {};
-type FileOptions<Id extends string, Data, B extends readonly LayoutBlock[], A extends readonly LayoutBlock[], I extends readonly LayoutBlock[]> = Omit<CreateLayoutOptions<B, A, I>, "id" | "kind" | "loader" | "component"> & ({
+/** Any layout. `Item` is typed per layout, and only exists on record layouts' types. */
+export type Layout = Omit<ReturnType<typeof createLayoutDefinition>, "Item">;
+/** A layout typed by its loader: `useData` returns the loaded data, `Item` renders its record. */
+type LayoutFor<Result extends LoaderReturn> = Omit<Layout, "useData" | "Item"> & {
+  useData: () => LoaderData<Result>;
+} & ItemScope<RecordFields<Result>>;
+export interface LayoutFileRoutes {}
+type Params<Id extends string> = Id extends `${infer Head}.${infer Tail}` ? Params<Head> & Params<Tail> : Id extends `$${infer Name}` ? { [K in Name]: string; } : {};
+type RouteParams<Id extends string> = Id extends keyof LayoutFileRoutes ? LayoutFileRoutes[Id] extends {
+  params: infer P;
+} ? P : Params<Id> : Params<Id>;
+type FileOptions<Id extends string, Result extends LoaderReturn, B extends readonly LayoutBlock[], A extends readonly LayoutBlock[], I extends readonly InitialBlockImport[]> = Omit<CreateLayoutOptions<B, A, I>, "id" | "kind" | "loader" | "routes" | "recordPages" | "component" | "buildMetaTitle" | "buildMetaDescription" | "toMarkdown"> & ({
   kind: "curated";
   component: React.ComponentType<{
     children: React.ReactNode;
   }>;
   loader?: never;
+  routes?: never;
+  recordPages?: never;
+  toMarkdown?: never;
+  buildMetaTitle: BuildMetaTitle<undefined, Record<string, never>>;
+  buildMetaDescription?: BuildMetaDescription<undefined, Record<string, never>>;
 } | {
   kind: "singleton";
   blocks: {
@@ -163,12 +302,15 @@ type FileOptions<Id extends string, Data, B extends readonly LayoutBlock[], A ex
     after: ValidateLayoutOnlyBlocks<A>;
     initial?: never;
   };
-  loader?: (context: {
-    params: Record<string, never>;
-  }) => Data;
+  loader?: (context: LayoutLoaderContext<Record<string, never>>) => Result;
+  routes?: never;
+  recordPages?: never;
+  toMarkdown?: LayoutToMarkdown<LoaderData<Result>, Record<string, never>, RecordFields<Result>>;
   component: React.ComponentType<{
     children?: never;
   }>;
+  buildMetaTitle: BuildMetaTitle<LoaderData<Result>, Record<string, never>, RecordFields<Result>>;
+  buildMetaDescription?: BuildMetaDescription<LoaderData<Result>, Record<string, never>, RecordFields<Result>>;
 } | {
   kind: "derived";
   blocks: {
@@ -176,23 +318,17 @@ type FileOptions<Id extends string, Data, B extends readonly LayoutBlock[], A ex
     after: ValidateLayoutOnlyBlocks<A>;
     initial?: never;
   };
-  loader: (context: {
-    params: Id extends keyof LayoutFileRoutes ? LayoutFileRoutes[Id] extends {
-      params: infer P;
-    } ? P : Params<Id> : Params<Id>;
-  }) => Data;
+  loader: (context: LayoutLoaderContext<RouteParams<Id>>) => Result;
+  routes?: (context: LayoutRoutesContext) => RoutesReturn<RouteParams<Id>>;
+  recordPages?: RecordPages;
+  toMarkdown?: LayoutToMarkdown<LoaderData<Result>, RouteParams<Id>, RecordFields<Result>>;
   component: React.ComponentType<{
     children?: never;
   }>;
+  buildMetaTitle: BuildMetaTitle<LoaderData<Result>, RouteParams<Id>, RecordFields<Result>>;
+  buildMetaDescription?: BuildMetaDescription<LoaderData<Result>, RouteParams<Id>, RecordFields<Result>>;
 });
-declare function createLayout<const Id extends string>(id: Id): <Data = undefined, const B extends readonly LayoutBlock[] = [], const A extends readonly LayoutBlock[] = [], const I extends readonly LayoutBlock[] = []>(options: FileOptions<Id, Data, B, A, I>) => Omit<Layout, "useData"> & {
-  useData: () => Awaited<Data>;
-};
-declare function createLayout<const B extends readonly LayoutBlock[], const A extends readonly LayoutBlock[], const I extends readonly LayoutBlock[] = []>(options: CreateLayoutOptions<B, A, I>): Layout;
-/** Signal a missing derived page; other loader failures remain server errors. */
-declare function notFound(): Error & {
-  status: number;
-  code: string;
-};
+export declare function createLayout<const B extends readonly LayoutBlock[], const A extends readonly LayoutBlock[], const I extends readonly InitialBlockImport[] = [], Result extends LoaderReturn = never>(options: CreateLayoutOptions<B, A, I, Result>): LayoutFor<Result>;
+export declare function createLayout<const Id extends string>(id: Id): <Result extends LoaderReturn = never, const B extends readonly LayoutBlock[] = [], const A extends readonly LayoutBlock[] = [], const I extends readonly InitialBlockImport[] = []>(options: FileOptions<Id, Result, B, A, I>) => LayoutFor<Result>;
 //#endregion
-export { Layout, LayoutBlockData, LayoutFileRoutes, OgImageParams, createLayout, notFound };
+export { type LayoutRequestContext, notFound };