ampless 0.2.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,648 @@
+type ContentEventType = 'content.created' | 'content.updated' | 'content.published' | 'content.unpublished' | 'content.deleted';
+type MediaEventType = 'media.uploaded' | 'media.deleted';
+type SiteSettingsEventType = 'site.settings.updated';
+type EventType = ContentEventType | MediaEventType | SiteSettingsEventType;
+/** Minimal projection of a Post item carried in events (no body, to keep payloads small). */
+interface ContentEventPayload {
+    siteId: string;
+    postId: string;
+    slug: string;
+    title: string;
+    status: 'draft' | 'published';
+    publishedAt?: string;
+    tags?: string[];
+}
+interface MediaEventPayload {
+    siteId: string;
+    mediaId: string;
+    src: string;
+    mimeType: string;
+}
+/**
+ * Emitted whenever any setting under `siteconfig:{siteId}` in KvStore
+ * is created, updated, or removed. Subscribers (built-in or user
+ * plugins) can rebuild caches, theme assets, etc.
+ */
+interface SiteSettingsEventPayload {
+    siteId: string;
+}
+type EventPayloadOf<T extends EventType> = T extends ContentEventType ? ContentEventPayload : T extends MediaEventType ? MediaEventPayload : T extends SiteSettingsEventType ? SiteSettingsEventPayload : never;
+interface AmplessEvent<T extends EventType = EventType> {
+    type: T;
+    payload: EventPayloadOf<T>;
+    /** ISO 8601 timestamp of when the source mutation happened. */
+    timestamp: string;
+}
+/**
+ * Maps a single content mutation to the CMS-level events it represents.
+ * Always emits `content.updated` for any MODIFY so plugins that subscribe
+ * to "any change" reliably fire; status transitions add the matching
+ * published / unpublished event on top.
+ *
+ * Used by the DynamoDB Stream dispatcher Lambda — kept here so the same
+ * decision table is testable in plain Node without AWS deps.
+ */
+type StreamEventName = 'INSERT' | 'MODIFY' | 'REMOVE';
+declare function detectContentEvents(input: {
+    eventName: StreamEventName | string | undefined;
+    oldStatus?: 'draft' | 'published';
+    newStatus?: 'draft' | 'published';
+}): ContentEventType[];
+
+type TrustLevel = 'untrusted' | 'trusted' | 'privileged';
+/**
+ * Metadata-like object that maps cleanly onto Next.js `Metadata`. We keep
+ * the shape framework-agnostic so the core type doesn't depend on Next.js.
+ */
+interface PluginMetadata {
+    title?: string;
+    description?: string;
+    openGraph?: {
+        title?: string;
+        description?: string;
+        type?: string;
+        url?: string;
+        images?: Array<{
+            url: string;
+            width?: number;
+            height?: number;
+            alt?: string;
+        }>;
+    };
+    twitter?: {
+        card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+        site?: string;
+        creator?: string;
+        title?: string;
+        description?: string;
+        images?: string[];
+    };
+    alternates?: {
+        canonical?: string;
+        types?: Record<string, string>;
+    };
+}
+type PluginEventHandler<T extends EventType = EventType> = (event: AmplessEvent<T>, ctx: PluginRuntimeContext) => Promise<void>;
+/**
+ * Runtime services injected into hook handlers by the Lambda processor.
+ * Decoupling plugins from concrete AWS clients lets us swap implementations
+ * (sandbox, tests) without touching plugin code.
+ */
+interface PluginRuntimeContext {
+    siteId: string;
+    /** Read-only view of the cms.config site block (name, url, description). */
+    site: Config['site'];
+    /** Read all published posts for the site (used by sitemap/RSS). */
+    listPublishedPosts(): Promise<Post[]>;
+    /**
+     * Persist a file under `public/plugins/{pluginName}/{key}` in the site's
+     * S3 bucket. Returns the public URL.
+     */
+    writePublicAsset(key: string, body: string | Uint8Array, contentType: string): Promise<string>;
+}
+/**
+ * A font registered with a plugin's OG image renderer. Satori (the engine
+ * inside Next.js `ImageResponse`) requires at least one font. We accept
+ * either eager `ArrayBuffer` data or a lazy loader so plugins can be
+ * imported without forcing the font fetch — the loader runs once per route
+ * invocation when the OG image is actually requested.
+ */
+interface OgImageFont {
+    name: string;
+    data: ArrayBuffer | (() => Promise<ArrayBuffer>);
+    weight?: number;
+    style?: 'normal' | 'italic';
+}
+/**
+ * Context passed to a plugin's `ogImage.render`. The `image` helper fetches
+ * and decodes an image URL (WebP / AVIF → PNG) and returns a data URL
+ * usable inside the JSX, or null on fetch failure / unsupported format.
+ */
+interface OgImageRenderContext {
+    post: Post;
+    site: Config['site'];
+    image(url: string): Promise<string | null>;
+}
+interface OgImageConfig {
+    fonts: OgImageFont[];
+    size?: {
+        width: number;
+        height: number;
+    };
+    /**
+     * Plugin authors return a React element. Typed loosely (`unknown`) here
+     * to avoid pulling React into ampless core's runtime / type
+     * dependencies — the OG image plugin package types it precisely on its
+     * side.
+     */
+    render(ctx: OgImageRenderContext): Promise<unknown> | unknown;
+}
+interface AmplessPlugin {
+    name: string;
+    /** Plugin API version. Currently 1; future versions will be additive. */
+    apiVersion: 1;
+    trust_level: TrustLevel;
+    /** Async event hooks. Run in trust_level-matched Lambda. */
+    hooks?: {
+        [K in EventType]?: PluginEventHandler<K>;
+    };
+    /**
+     * Per-post metadata generator. Pure function, called from Next.js
+     * generateMetadata(). Must not have side effects.
+     */
+    metadata?(post: Post, site: Config['site']): PluginMetadata;
+    /**
+     * Site-level metadata (root layout). Returned per request.
+     */
+    siteMetadata?(site: Config['site']): PluginMetadata;
+    /**
+     * Dynamic OG image renderer. The dispatcher route (e.g.
+     * `app/site/[siteId]/og/[slug]/route.ts`) reads this and feeds the
+     * element into Next.js `ImageResponse`. Only one plugin should set this
+     * — the route resolves the first plugin in `cms.config.plugins` that
+     * declares `ogImage`.
+     */
+    ogImage?: OgImageConfig;
+}
+declare function definePlugin(p: AmplessPlugin): AmplessPlugin;
+
+type ContentFormat = 'tiptap' | 'markdown' | 'html';
+type PostStatus = 'draft' | 'published';
+interface Post {
+    postId: string;
+    siteId: string;
+    slug: string;
+    title: string;
+    excerpt?: string;
+    format: ContentFormat;
+    body: unknown;
+    status: PostStatus;
+    publishedAt?: string;
+    tags?: string[];
+}
+interface Page {
+    pageId: string;
+    siteId: string;
+    slug: string;
+    title: string;
+    format: ContentFormat;
+    body: unknown;
+    status: PostStatus;
+    publishedAt?: string;
+}
+interface Media {
+    mediaId: string;
+    siteId: string;
+    src: string;
+    mimeType: string;
+    size: number;
+    delivery: 'nextjs' | 's3-direct';
+}
+type ImageDisplay = 'inline' | 'lightbox';
+/**
+ * How dates (publishedAt etc.) are rendered on public pages.
+ * - 'iso'    YYYY-MM-DD (default; SSR-safe, locale-neutral)
+ * - 'locale' browser/server locale via Date.toLocaleDateString()
+ *            (warning: server uses Node default locale, so SSR/CSR may diverge)
+ * - 'long'   "April 27, 2026" (en-US long form)
+ */
+type DateFormat = 'iso' | 'locale' | 'long';
+interface MediaProcessingDefaults {
+    /** Clamp the longer edge to this many pixels (default 2400). */
+    maxDimension?: number;
+    /** Default output format (default 'webp'). */
+    format?: 'webp' | 'jpeg' | 'original';
+    /** Lossy quality 0..1 used when format is lossy (default 0.85). */
+    quality?: number;
+    /** Use lossless WebP for PNG inputs (default true). */
+    losslessForPng?: boolean;
+}
+/**
+ * Per-site override. The top-level `Config.site` provides defaults that
+ * fall through when these are unset. `domains` is required because it's
+ * how the middleware maps incoming requests to a siteId.
+ */
+interface SiteConfig {
+    /** Hostnames this site responds to (subdomains, separate apex domains, both fine). */
+    domains: string[];
+    /** Override `Config.site.name` for this site. */
+    name?: string;
+    /** Override `Config.site.url` (canonical) for this site. */
+    url?: string;
+    /** Override `Config.site.description` for this site. */
+    description?: string;
+}
+interface Config {
+    site: {
+        name: string;
+        url: string;
+        description?: string;
+    };
+    media?: {
+        delivery?: 'nextjs' | 's3-direct';
+        /** How embedded images are presented on the public site. */
+        imageDisplay?: ImageDisplay;
+        /** Max content width for inline images (CSS value, default '100%'). */
+        imageMaxWidth?: string;
+        /** Defaults for the upload-time image processing UI. */
+        processing?: MediaProcessingDefaults;
+    };
+    /** How dates render on public pages. Default 'iso' (YYYY-MM-DD). */
+    dateFormat?: DateFormat;
+    /**
+     * IANA timezone for date display (e.g. 'Asia/Tokyo', 'America/New_York').
+     * Default 'UTC'. Used so SSR and CSR always produce the same string —
+     * relying on the runtime's local TZ would drift between Node (UTC in
+     * production) and the browser.
+     */
+    timezone?: string;
+    /**
+     * UI locale for the admin app. The scaffolded project ships
+     * `locales/<code>.json` dictionaries; defaults are `en` and `ja`.
+     * Add a new language by dropping `locales/<code>.json` in and
+     * updating the dictionary map in `lib/i18n.ts`. Per-site override is
+     * possible via the `locale` site setting.
+     */
+    locale?: string;
+    /**
+     * Multi-site configuration. When 2+ entries are declared, the runtime
+     * switches to multi-site mode (host-based routing + Cache-Control:
+     * private). When 0 or 1 entries, single-site mode is used.
+     */
+    sites?: Record<string, SiteConfig>;
+    /**
+     * Active plugins. Each entry is the result of a plugin factory call
+     * (e.g. `seoPlugin({ ... })`) or a raw AmplessPlugin object. Strings are
+     * accepted for backward compatibility with the legacy v0 config but are
+     * ignored by the runtime.
+     */
+    plugins?: Array<AmplessPlugin | string>;
+}
+type Role = 'reader' | 'editor' | 'admin';
+interface AuthContext {
+    userId: string;
+    role: Role;
+    source: 'cognito' | 'api-key' | 'mcp';
+}
+
+declare function defineConfig(config: Config): Config;
+
+type FieldType = 'string' | 'text' | 'number' | 'boolean' | 'datetime' | 'image' | 'reference';
+interface FieldDefinition {
+    type: FieldType;
+    label?: string;
+    required?: boolean;
+    default?: unknown;
+}
+interface ContentTypeDefinition {
+    name: string;
+    label: string;
+    fields: Record<string, FieldDefinition>;
+}
+declare function defineSchema<T extends Record<string, ContentTypeDefinition>>(schema: T): T;
+
+interface ListOptions {
+    siteId?: string;
+    limit?: number;
+    status?: 'draft' | 'published' | 'all';
+}
+type CreatePostInput = Omit<Post, 'postId'> & {
+    postId?: string;
+};
+interface PostsProvider {
+    list(opts?: ListOptions): Promise<Post[]>;
+    get(slug: string, opts?: {
+        siteId?: string;
+    }): Promise<Post | null>;
+    getById(postId: string, opts?: {
+        siteId?: string;
+    }): Promise<Post | null>;
+    create(data: CreatePostInput): Promise<Post>;
+    update(postId: string, data: Partial<Post>, opts?: {
+        siteId?: string;
+    }): Promise<Post>;
+    remove(postId: string, opts?: {
+        siteId?: string;
+    }): Promise<void>;
+}
+declare function setPostsProvider(p: PostsProvider): void;
+declare function hasPostsProvider(): boolean;
+declare function listPosts(opts?: ListOptions): Promise<Post[]>;
+declare function getPost(slug: string, opts?: {
+    siteId?: string;
+}): Promise<Post | null>;
+declare function getPostById(postId: string, opts?: {
+    siteId?: string;
+}): Promise<Post | null>;
+declare function createPost(data: CreatePostInput): Promise<Post>;
+declare function updatePost(postId: string, data: Partial<Post>, opts?: {
+    siteId?: string;
+}): Promise<Post>;
+declare function deletePost(postId: string, opts?: {
+    siteId?: string;
+}): Promise<void>;
+
+/**
+ * Single-site fallback identifier. Used when `cms.config.sites` is unset
+ * or empty — keeps existing single-site code paths working without
+ * special-casing.
+ */
+declare const DEFAULT_SITE_ID = "default";
+/**
+ * Resolve a hostname to a configured siteId.
+ *
+ * - Single-site mode (no `sites` defined or empty): always returns
+ *   `DEFAULT_SITE_ID` regardless of host. The single site catches
+ *   every request.
+ * - Multi-site mode: looks up the host in each site's `domains` list.
+ *   Returns `null` if the host is not registered (caller should 404).
+ *
+ * The host comparison is case-insensitive; ports are not stripped here
+ * — pass the bare hostname (e.g. `'site-a.example.com'`).
+ */
+declare function resolveSiteId(host: string, config: Config): string | null;
+/**
+ * Multi-site mode iff two or more sites are declared. A single declared
+ * site is treated as single-site mode (the explicit declaration just lets
+ * the operator name the site, but no host disambiguation is needed).
+ */
+declare function isMultiSite(config: Config): boolean;
+/**
+ * Site-effective name / url / description for a given siteId. Per-site
+ * `sites.{id}.{name|url|description}` overrides the top-level `site.*`
+ * defaults; otherwise falls through.
+ */
+declare function siteFor(siteId: string, config: Config): {
+    name: string;
+    url: string;
+    description?: string;
+};
+/**
+ * Build the denormalized GSI key for `bySiteIdStatus`. All Post writes
+ * (admin client, MCP tools) must set this so the public-read resolvers
+ * can do a single Query without table-level filtering.
+ */
+declare function composeSiteIdStatus(siteId: string, status: PostStatus): string;
+/**
+ * Build the denormalized GSI key for `bySiteIdSlug`. The public
+ * `getPublishedPost(slug)` resolver does an O(1) PK lookup against
+ * this index, so every Post write must set it alongside the slug.
+ */
+declare function composeSiteIdSlug(siteId: string, slug: string): string;
+
+interface KvItem<T = unknown> {
+    pk: string;
+    sk: string;
+    value: T;
+    /** Unix epoch seconds. Absent → persistent. */
+    ttl?: number;
+}
+interface KvStore {
+    get<T = unknown>(pk: string, sk: string): Promise<T | null>;
+    query<T = unknown>(pk: string): Promise<KvItem<T>[]>;
+    put(pk: string, sk: string, value: unknown, opts?: {
+        ttlSeconds?: number;
+    }): Promise<void>;
+    remove(pk: string, sk: string): Promise<void>;
+}
+declare function setKvStore(s: KvStore): void;
+declare function hasKvStore(): boolean;
+declare const SITE_CONFIG_PK: (siteId: string) => string;
+declare function getSiteSetting<T = unknown>(siteId: string, key: string): Promise<T | null>;
+declare function setSiteSetting(siteId: string, key: string, value: unknown): Promise<void>;
+declare function deleteSiteSetting(siteId: string, key: string): Promise<void>;
+/**
+ * Fetch every setting for a site as a flat map (`{ 'site.name': 'My Blog', ... }`).
+ * Use `unflattenSettings` to convert to the nested shape if needed.
+ */
+declare function listSiteSettings(siteId?: string): Promise<Record<string, unknown>>;
+declare function flattenSettings(obj: Record<string, unknown>, prefix?: string): Record<string, unknown>;
+declare function unflattenSettings(flat: Record<string, unknown>): Record<string, unknown>;
+
+/**
+ * Format a date for display in a fixed timezone. SSR-safe — the same
+ * (input, format, timezone) tuple yields the same string on Node and in
+ * the browser, so React hydration never drifts.
+ *
+ * @param input    Date, ISO string, or epoch ms
+ * @param format   'iso' (YYYY-MM-DD), 'long' (April 27, 2026), 'locale'
+ * @param timezone IANA TZ name. Default 'UTC'.
+ */
+declare function formatDate(input: Date | string | number, format?: DateFormat, timezone?: string): string;
+
+declare function escapeXml(s: string): string;
+
+/**
+ * Build the public S3 URL for an object key, in the regional virtual-host
+ * style: `https://{bucket}.s3.{region}.amazonaws.com/{key}`. The legacy
+ * non-regional form (`s3.amazonaws.com`) issues redirects and is avoided.
+ */
+declare function formatPublicAssetUrl(bucket: string, region: string, key: string): string;
+
+/**
+ * Extract the first image URL from a post body. Used by plugins (e.g.
+ * plugin-og-image) that want to derive an image from the post content
+ * without requiring authors to set an explicit featured image field.
+ *
+ * Returns null if the post has no image, or if the body shape doesn't
+ * match the declared `post.format`.
+ *
+ * Format handling:
+ *  - 'tiptap'   — body is the tiptap JSON tree; walks for `type === 'image'`
+ *  - 'markdown' — body is a string; finds the first `![alt](src)`
+ *  - 'html'     — body is a string; finds the first `<img src="...">`
+ */
+declare function extractFirstImageUrl(post: Post): string | null;
+
+type ThemeFieldType = 'color' | 'text' | 'select' | 'image' | 'length' | 'fontFamily' | 'linkList';
+/**
+ * Single entry in a `linkList` field. Stored as part of a JSON array
+ * under the field's storage key. `url` may be:
+ *  - a relative path (`/about`)
+ *  - an absolute URL (`https://example.com`)
+ *  - a tag reference (`tag:guide`) — themes interpret this as
+ *    "expand to a list of posts with this tag" rather than rendering
+ *    a literal link.
+ */
+interface LinkListItem {
+    label: string;
+    url: string;
+}
+/**
+ * A user-facing string in a manifest. Either a plain string (rendered
+ * as-is, regardless of locale) or a per-locale map (the renderer picks
+ * the active locale, falling back to `en`, then to any value).
+ *
+ * Themes that ship in a single language can keep these as plain
+ * strings. The default themes use the map form so the same manifest
+ * works for both built-in dictionaries.
+ */
+type LocalizedString = string | Record<string, string>;
+interface ThemeFieldBase {
+    /** Storage key. Persisted as `theme.{key}` in site settings. */
+    key: string;
+    label: LocalizedString;
+    description?: LocalizedString;
+    /** Optional UI grouping (e.g. 'Colors', 'Typography', 'Branding'). */
+    group?: LocalizedString;
+    /** Used when no override is set. Always a string for storage uniformity. */
+    default: string;
+    /**
+     * If set, the loader injects `${cssVar}: ${value}` into a `:root`
+     * style block on every public page, so CSS rules using
+     * `var(${cssVar})` pick up overrides at render time.
+     *
+     * Fields without `cssVar` (e.g. logo URL, header tagline) are exposed
+     * to template code via `loadThemeConfig()` instead.
+     */
+    cssVar?: string;
+}
+interface ThemeColorField extends ThemeFieldBase {
+    type: 'color';
+}
+interface ThemeTextField extends ThemeFieldBase {
+    type: 'text';
+    maxLength?: number;
+}
+interface ThemeSelectField extends ThemeFieldBase {
+    type: 'select';
+    options: ReadonlyArray<{
+        value: string;
+        label: LocalizedString;
+    }>;
+}
+interface ThemeImageField extends ThemeFieldBase {
+    type: 'image';
+}
+interface ThemeLengthField extends ThemeFieldBase {
+    type: 'length';
+}
+interface ThemeFontFamilyField extends ThemeFieldBase {
+    type: 'fontFamily';
+    options: ReadonlyArray<{
+        value: string;
+        label: LocalizedString;
+    }>;
+}
+/**
+ * A repeatable list of {label, url} entries — used for nav menus,
+ * footer link sets, sidebar groups, etc. Stored in KvStore as a JSON
+ * string so it fits the existing `string`-valued site-settings cache.
+ *
+ * `default` is declared as a plain array for ergonomics; the loader
+ * stringifies it on the fly so manifest authors don't have to call
+ * JSON.stringify by hand.
+ */
+interface ThemeLinkListField extends Omit<ThemeFieldBase, 'default' | 'cssVar'> {
+    type: 'linkList';
+    default: ReadonlyArray<LinkListItem>;
+    /** Cap admin-supplied list length. Default 50. */
+    maxItems?: number;
+}
+type ThemeField = ThemeColorField | ThemeTextField | ThemeSelectField | ThemeImageField | ThemeLengthField | ThemeFontFamilyField | ThemeLinkListField;
+interface ThemeManifest {
+    /** Theme directory name (`themes/<name>/`). */
+    name: string;
+    label: LocalizedString;
+    description?: LocalizedString;
+    fields: ReadonlyArray<ThemeField>;
+}
+declare function defineTheme(m: ThemeManifest): ThemeManifest;
+/**
+ * Resolve a `LocalizedString` to a plain string for display.
+ * Strings pass through; maps pick `locale` → `fallback` → any value
+ * → empty. The empty fallback keeps the renderer from crashing on a
+ * malformed manifest while making the missing translation visible.
+ */
+declare function resolveLocalized(value: LocalizedString | undefined, locale: string, fallback?: string): string;
+interface ThemeRouteContext<P = Record<string, string>> {
+    params: Promise<P & {
+        siteId: string;
+    }>;
+}
+interface ThemeModule {
+    /** Stable identifier — must match the directory name and the value
+     *  stored as `theme.active`. */
+    name: string;
+    manifest: ThemeManifest;
+    /**
+     * Server components rendered by the dispatcher routes under
+     * `app/site/[siteId]/`. Each theme MUST provide Home; Post / Tag are
+     * recommended but optional (dispatcher 404s when missing).
+     */
+    components: {
+        Home: (ctx: ThemeRouteContext) => Promise<unknown> | unknown;
+        Post?: (ctx: ThemeRouteContext<{
+            slug: string;
+        }>) => Promise<unknown> | unknown;
+        Tag?: (ctx: ThemeRouteContext<{
+            tag: string;
+        }>) => Promise<unknown> | unknown;
+    };
+    /**
+     * Optional `generateMetadata` hooks called by the dispatcher. Same
+     * signature as the matching component's params.
+     */
+    metadata?: {
+        Home?: (ctx: ThemeRouteContext) => Promise<unknown> | unknown;
+        Post?: (ctx: ThemeRouteContext<{
+            slug: string;
+        }>) => Promise<unknown> | unknown;
+        Tag?: (ctx: ThemeRouteContext<{
+            tag: string;
+        }>) => Promise<unknown> | unknown;
+    };
+    /**
+     * Optional route handlers for /feed.xml and /sitemap.xml. The
+     * dispatcher returns 404 if a theme doesn't provide them.
+     */
+    routes?: {
+        feed?: (ctx: {
+            siteId: string;
+            request: Request;
+        }) => Promise<Response>;
+        sitemap?: (ctx: {
+            siteId: string;
+            request: Request;
+        }) => Promise<Response>;
+    };
+}
+declare function defineThemeModule(m: ThemeModule): ThemeModule;
+/**
+ * Storage key used in KvStore. Prefix `theme.` keeps the namespace
+ * separate from `site.*` / `media.*` so unrelated tools can scan
+ * settings without colliding.
+ */
+declare function themeSettingKey(fieldKey: string): string;
+/**
+ * Reject malformed or potentially-injectable values before they reach
+ * the KvStore. Admin/editor are trusted but typos and copy-paste
+ * mistakes shouldn't be able to break a site's CSS or sneak `</style>`
+ * into the inline tag the loader emits.
+ *
+ * Returns the normalized value, or null if the input is rejected.
+ */
+declare function validateThemeValue(field: ThemeField, raw: unknown): string | null;
+/** Parse a stored linkList JSON value into typed items. Tolerant: bad
+ *  shapes resolve to []. Throwing here would cascade into rendering. */
+declare function parseLinkList(raw: string | undefined | null): LinkListItem[];
+declare function stringifyLinkList(items: ReadonlyArray<LinkListItem>): string;
+/**
+ * Detect a `tag:<name>` URL form. Themes use this to render a list of
+ * posts under a heading instead of a literal link — useful for docs
+ * sidebars and category-style nav.
+ */
+declare function isTagListUrl(url: string): {
+    tag: string;
+} | null;
+/**
+ * Resolve effective values for every manifest field, merging stored
+ * overrides on top of defaults. `stored` is the flat settings map keyed
+ * by `theme.{key}` — typically the output of `listSiteSettings(siteId)`
+ * filtered to theme entries.
+ */
+declare function resolveThemeValues(manifest: ThemeManifest, stored: Record<string, unknown>): Record<string, string>;
+
+declare const VERSION = "0.0.1";
+
+export { type AmplessEvent, type AmplessPlugin, type AuthContext, type Config, type ContentEventPayload, type ContentEventType, type ContentFormat, type ContentTypeDefinition, type CreatePostInput, DEFAULT_SITE_ID, type DateFormat, type EventPayloadOf, type EventType, type FieldDefinition, type FieldType, type ImageDisplay, type KvItem, type KvStore, type LinkListItem, type ListOptions, type LocalizedString, type Media, type MediaEventPayload, type MediaEventType, type MediaProcessingDefaults, type OgImageConfig, type OgImageFont, type OgImageRenderContext, type Page, type PluginEventHandler, type PluginMetadata, type PluginRuntimeContext, type Post, type PostStatus, type PostsProvider, type Role, SITE_CONFIG_PK, type SiteConfig, type SiteSettingsEventPayload, type SiteSettingsEventType, type StreamEventName, type ThemeColorField, type ThemeField, type ThemeFieldType, type ThemeFontFamilyField, type ThemeImageField, type ThemeLengthField, type ThemeLinkListField, type ThemeManifest, type ThemeModule, type ThemeRouteContext, type ThemeSelectField, type ThemeTextField, type TrustLevel, VERSION, composeSiteIdSlug, composeSiteIdStatus, createPost, defineConfig, definePlugin, defineSchema, defineTheme, defineThemeModule, deletePost, deleteSiteSetting, detectContentEvents, escapeXml, extractFirstImageUrl, flattenSettings, formatDate, formatPublicAssetUrl, getPost, getPostById, getSiteSetting, hasKvStore, hasPostsProvider, isMultiSite, isTagListUrl, listPosts, listSiteSettings, parseLinkList, resolveLocalized, resolveSiteId, resolveThemeValues, setKvStore, setPostsProvider, setSiteSetting, siteFor, stringifyLinkList, themeSettingKey, unflattenSettings, updatePost, validateThemeValue };