dineway 0.1.11 → 0.1.13

package/dist/index-EUAWaIxW.d.mts

@@ -0,0 +1,835 @@
+import { t as Database } from "./types-DZPw8Rru.mjs";
+import { a as Collection, i as SiteSettings, r as SiteSettingKey } from "./types-C0mmVRJN.mjs";
+import { m as MediaValue } from "./types-OPs5Q_sX.mjs";
+import { Kysely } from "kysely";
+import { z } from "astro/zod";
+
+//#region src/database/repositories/comment.d.ts
+/** Public-facing comment shape — no private fields */
+interface PublicComment {
+  id: string;
+  parentId: string | null;
+  authorName: string;
+  isRegisteredUser: boolean;
+  body: string;
+  createdAt: string;
+  replies?: PublicComment[];
+}
+//#endregion
+//#region src/fields/types.d.ts
+/**
+ * SQLite column types that map from field types
+ */
+type ColumnType = "TEXT" | "REAL" | "INTEGER" | "JSON";
+/**
+ * Base field definition
+ *
+ * Note: schema uses z.ZodTypeAny to accommodate optional/default wrappers
+ */
+interface FieldDefinition<_T = unknown> {
+  type: string;
+  /**
+   * The SQLite column type to use when storing this field
+   */
+  columnType: ColumnType;
+  schema: z.ZodTypeAny;
+  options?: unknown;
+  ui?: FieldUIHints;
+}
+/**
+ * UI hints for admin rendering
+ */
+interface FieldUIHints {
+  widget?: string;
+  placeholder?: string;
+  helpText?: string;
+  rows?: number;
+  min?: number | string;
+  max?: number | string;
+  [key: string]: unknown;
+}
+/**
+ * Portable Text block structure
+ */
+interface PortableTextBlock {
+  _type: string;
+  _key: string;
+  [key: string]: unknown;
+}
+/**
+ * @deprecated Use MediaValue instead. ImageValue is an alias for backwards compatibility.
+ */
+type ImageValue = MediaValue;
+/**
+ * File field value
+ */
+interface FileValue {
+  id: string;
+  url: string;
+  filename: string;
+  mimeType: string;
+  size: number;
+}
+//#endregion
+//#region src/fields/image.d.ts
+/**
+ * Image field
+ * References media items from the media library
+ */
+declare function image(options?: {
+  required?: boolean;
+  maxSize?: number;
+  allowedTypes?: string[];
+}): FieldDefinition<ImageValue | undefined>;
+//#endregion
+//#region src/fields/reference.d.ts
+/**
+ * Reference field
+ * References another content item by ID
+ */
+declare function reference(collection: string, options?: {
+  required?: boolean;
+}): FieldDefinition<string | undefined>;
+//#endregion
+//#region src/fields/portable-text.d.ts
+/**
+ * Portable Text field
+ * Stores structured content in Portable Text format
+ */
+declare function portableText(options?: {
+  required?: boolean;
+}): FieldDefinition<PortableTextBlock[] | undefined>;
+//#endregion
+//#region src/schema/query.d.ts
+/**
+ * Get collection metadata by slug.
+ *
+ * @example
+ * ```ts
+ * import { getCollectionInfo } from "dineway";
+ *
+ * const info = await getCollectionInfo("posts");
+ * if (info?.commentsEnabled) {
+ *   // render comment UI
+ * }
+ * ```
+ */
+declare function getCollectionInfo(slug: string): Promise<Collection | null>;
+//#endregion
+//#region src/utils/url.d.ts
+/**
+ * URL scheme validation utilities
+ *
+ * Prevents XSS via dangerous URL schemes (javascript:, data:, vbscript:, etc.)
+ * by allowlisting known-safe schemes before rendering into href attributes.
+ */
+/**
+ * Returns the URL unchanged if it uses a safe scheme, otherwise returns "#".
+ *
+ * Use this at the render layer as the primary defense against XSS via
+ * dangerous URL schemes like `javascript:`, `data:`, or `vbscript:`.
+ *
+ * @example
+ * ```ts
+ * sanitizeHref("https://example.com")        // "https://example.com"
+ * sanitizeHref("/about")                      // "/about"
+ * sanitizeHref("#section")                    // "#section"
+ * sanitizeHref("mailto:a@b.com")              // "mailto:a@b.com"
+ * sanitizeHref("javascript:alert(1)")         // "#"
+ * sanitizeHref("data:text/html,<script>")     // "#"
+ * sanitizeHref("")                            // "#"
+ * ```
+ */
+declare function sanitizeHref(url: string | undefined | null): string;
+/**
+ * Returns true if the URL uses a safe scheme for rendering in href attributes.
+ */
+declare function isSafeHref(url: string): boolean;
+//#endregion
+//#region src/visual-editing/editable.d.ts
+/**
+ * Visual editing annotation system
+ *
+ * Creates Proxy objects that emit data-dineway-ref attributes when spread onto elements.
+ */
+interface CMSAnnotation {
+  collection: string;
+  id: string;
+  field?: string;
+  /** Entry status — only present on entry-level annotations (not field-level) */
+  status?: string;
+  /** Whether the entry has unpublished draft changes */
+  hasDraft?: boolean;
+}
+/** The shape returned when spreading an edit annotation onto an element */
+interface FieldAnnotation {
+  "data-dineway-ref": string;
+}
+interface EditableOptions {
+  /** Entry status: "draft", "published", "scheduled" */
+  status?: string;
+  /** true when draftRevisionId exists and differs from liveRevisionId */
+  hasDraft?: boolean;
+}
+/**
+ * Create an editable proxy for an entry.
+ *
+ * Usage:
+ * - `{...entry.edit}` - entry-level annotation (includes status/hasDraft)
+ * - `{...entry.edit.title}` - field-level annotation
+ * - `{...entry.edit['nested.field']}` - nested field (bracket notation)
+ */
+declare function createEditable(collection: string, id: string, options?: EditableOptions): EditProxy;
+/**
+ * Create a noop proxy for production mode.
+ * Spreading this produces no attributes.
+ */
+declare function createNoop(): EditProxy;
+/**
+ * Visual editing proxy type.
+ *
+ * Spread directly onto elements for entry-level annotations: `{...entry.edit}`
+ * Access a field for field-level annotations: `{...entry.edit.title}`
+ *
+ * In production, spreading produces no attributes (noop).
+ */
+type EditProxy = {
+  readonly [field: string]: Partial<FieldAnnotation>;
+};
+//#endregion
+//#region src/query.d.ts
+/**
+ * Collection type registry for type-safe queries.
+ *
+ * This interface is extended by the generated dineway-env.d.ts file
+ * to provide type inference for collection names and their data shapes.
+ *
+ * @example
+ * ```ts
+ * // In dineway-env.d.ts (generated):
+ * declare module "dineway" {
+ *   interface DinewayCollections {
+ *     posts: { title: string; content: PortableTextBlock[]; };
+ *     pages: { title: string; body: PortableTextBlock[]; };
+ *   }
+ * }
+ *
+ * // Then in your code:
+ * const { entries } = await getDinewayCollection("posts");
+ * // entries[0].data.title is typed as string
+ * ```
+ */
+interface DinewayCollections {}
+/**
+ * Helper type to infer the data type for a collection.
+ * Returns the registered type if known, otherwise falls back to Record<string, unknown>.
+ */
+type InferCollectionData<T extends string> = T extends keyof DinewayCollections ? DinewayCollections[T] : Record<string, unknown>;
+/**
+ * Sort direction
+ */
+type SortDirection = "asc" | "desc";
+/**
+ * Order by specification - field name to direction
+ * @example { created_at: "desc" } - Sort by created_at descending
+ * @example { title: "asc" } - Sort by title ascending
+ * @example { published_at: "desc", title: "asc" } - Multi-field sort
+ */
+type OrderBySpec = Record<string, SortDirection>;
+interface CollectionFilter {
+  status?: "draft" | "published" | "archived";
+  limit?: number;
+  /**
+   * Opaque cursor for keyset pagination.
+   * Pass the `nextCursor` value from a previous result to fetch the next page.
+   * @example
+   * ```ts
+   * const cursor = Astro.url.searchParams.get("cursor") ?? undefined;
+   * const { entries, nextCursor } = await getDinewayCollection("posts", {
+   *   limit: 10,
+   *   cursor,
+   * });
+   * ```
+   */
+  cursor?: string;
+  /**
+   * Filter by field values or taxonomy terms
+   * @example { category: 'news' } - Filter by taxonomy term
+   * @example { category: ['news', 'featured'] } - Filter by multiple terms (OR)
+   */
+  where?: Record<string, string | string[]>;
+  /**
+   * Order results by field(s)
+   * @default { created_at: "desc" }
+   * @example { created_at: "desc" } - Sort by created_at descending (default)
+   * @example { title: "asc" } - Sort by title ascending
+   * @example { published_at: "desc", title: "asc" } - Multi-field sort
+   */
+  orderBy?: OrderBySpec;
+  /**
+   * Filter by locale. When set, only returns entries in this locale.
+   * Only relevant when i18n is configured.
+   * @example "en" — English entries only
+   * @example "fr" — French entries only
+   */
+  locale?: string;
+}
+interface ContentEntry<T = Record<string, unknown>> {
+  id: string;
+  data: T;
+  /** Visual editing annotations. Spread onto elements: {...entry.edit.title} */
+  edit: EditProxy;
+}
+/** Cache hint returned by the content loader for route caching */
+interface CacheHint {
+  tags?: string[];
+  lastModified?: Date;
+}
+/**
+ * Result from getDinewayCollection
+ */
+interface CollectionResult<T> {
+  /** The entries (empty array if error or none found) */
+  entries: ContentEntry<T>[];
+  /** Error if the query failed */
+  error?: Error;
+  /** Cache hint for route caching (pass to Astro.cache.set()) */
+  cacheHint: CacheHint;
+  /**
+   * Opaque cursor for the next page.
+   * Undefined when there are no more results.
+   * Pass this as `cursor` in the next query to get the next page.
+   */
+  nextCursor?: string;
+}
+/**
+ * Result from getDinewayEntry
+ */
+interface EntryResult<T> {
+  /** The entry, or null if not found */
+  entry: ContentEntry<T> | null;
+  /** Error if the query failed (not set for "not found", only for actual errors) */
+  error?: Error;
+  /** Whether we're in preview mode (valid token was provided) */
+  isPreview: boolean;
+  /** Set when a fallback locale was used instead of the requested locale */
+  fallbackLocale?: string;
+  /** Cache hint for route caching (pass to Astro.cache.set()) */
+  cacheHint: CacheHint;
+}
+/** Edit metadata attached to PT arrays in edit mode */
+interface EditFieldMeta {
+  collection: string;
+  id: string;
+  field: string;
+}
+/**
+ * Read edit metadata from a value (returns undefined if not tagged).
+ * Uses Object.getOwnPropertyDescriptor to access Symbol-keyed property
+ * without an unsafe type assertion.
+ */
+declare function getEditMeta(value: unknown): EditFieldMeta | undefined;
+/**
+ * Get all entries of a content type
+ *
+ * Returns { entries, error } for graceful error handling.
+ *
+ * When dineway-env.d.ts is generated, the collection name will be
+ * type-checked and the return type will be inferred automatically.
+ *
+ * @example
+ * ```ts
+ * import { getDinewayCollection } from "dineway";
+ *
+ * const { entries: posts, error } = await getDinewayCollection("posts");
+ * if (error) {
+ *   console.error("Failed to load posts:", error);
+ *   return;
+ * }
+ * // posts[0].data.title is typed (if dineway-env.d.ts exists)
+ *
+ * // With filters
+ * const { entries: drafts } = await getDinewayCollection("posts", { status: "draft" });
+ * ```
+ */
+declare function getDinewayCollection<T extends string, D = InferCollectionData<T>>(type: T, filter?: CollectionFilter): Promise<CollectionResult<D>>;
+/**
+ * Get a single entry by type and ID/slug
+ *
+ * Returns { entry, error, isPreview } for graceful error handling.
+ * - entry is null if not found (not an error)
+ * - error is set only for actual errors (db issues, etc.)
+ *
+ * Preview mode is detected automatically from request context (ALS).
+ * When the URL has a valid `_preview` token, the middleware sets preview
+ * context and this function serves draft revision data if available.
+ *
+ * @example
+ * ```ts
+ * import { getDinewayEntry } from "dineway";
+ *
+ * // Simple usage — preview just works via middleware
+ * const { entry: post, isPreview, error } = await getDinewayEntry("posts", "my-slug");
+ * if (!post) return Astro.redirect("/404");
+ * ```
+ */
+declare function getDinewayEntry<T extends string, D = InferCollectionData<T>>(type: T, id: string, options?: {
+  locale?: string;
+}): Promise<EntryResult<D>>;
+/**
+ * Translation summary for a single locale variant
+ */
+interface TranslationSummary {
+  /** Content item ID */
+  id: string;
+  /** Locale code (e.g. "en", "fr") */
+  locale: string;
+  /** URL slug */
+  slug: string | null;
+  /** Current status */
+  status: string;
+}
+/**
+ * Result from getTranslations
+ */
+interface TranslationsResult {
+  /** The translation group ID (shared across locales) */
+  translationGroup: string;
+  /** All locale variants in this group */
+  translations: TranslationSummary[];
+  /** Error if the query failed */
+  error?: Error;
+}
+/**
+ * Get all translations of a content item.
+ *
+ * Given a content entry, returns all locale variants that share the same
+ * translation group. This is useful for building language switcher UI.
+ *
+ * @example
+ * ```ts
+ * import { getDinewayEntry, getTranslations } from "dineway";
+ *
+ * const { entry: post } = await getDinewayEntry("posts", "hello-world", { locale: "en" });
+ * const { translations } = await getTranslations("posts", post.data.id);
+ * // translations = [{ id: "...", locale: "en", slug: "hello-world", status: "published" }, ...]
+ * ```
+ */
+declare function getTranslations(type: string, id: string): Promise<TranslationsResult>;
+/**
+ * Result from resolveDinewayPath
+ */
+interface ResolvePathResult<T = Record<string, unknown>> {
+  /** The matched entry */
+  entry: ContentEntry<T>;
+  /** The collection slug that matched */
+  collection: string;
+  /** Extracted parameters from the URL pattern (e.g. { slug: "my-post" }) */
+  params: Record<string, string>;
+}
+/**
+ * Resolve a URL path to a content entry by matching against collection URL patterns.
+ *
+ * Loads all collections with a `urlPattern` set, converts each pattern to a regex,
+ * and tests the given path. On match, extracts the slug and fetches the entry.
+ *
+ * @example
+ * ```ts
+ * import { resolveDinewayPath } from "dineway";
+ *
+ * // Given pages with urlPattern "/{slug}" and posts with "/blog/{slug}":
+ * const result = await resolveDinewayPath("/blog/hello-world");
+ * if (result) {
+ *   console.log(result.collection); // "posts"
+ *   console.log(result.params.slug); // "hello-world"
+ *   console.log(result.entry.data); // post data
+ * }
+ * ```
+ */
+declare function resolveDinewayPath<T = Record<string, unknown>>(path: string): Promise<ResolvePathResult<T> | null>;
+//#endregion
+//#region src/settings/index.d.ts
+/**
+ * Get a single site setting by key
+ *
+ * Returns `undefined` if the setting has not been configured.
+ * For media settings (logo, favicon), the URL is resolved automatically.
+ *
+ * @param key - The setting key (e.g., "title", "logo", "social")
+ * @returns The setting value, or undefined if not set
+ *
+ * @example
+ * ```ts
+ * import { getSiteSetting } from "dineway";
+ *
+ * const title = await getSiteSetting("title");
+ * const logo = await getSiteSetting("logo");
+ * console.log(logo?.url); // Resolved URL
+ * ```
+ */
+declare function getSiteSetting<K extends SiteSettingKey>(key: K): Promise<SiteSettings[K] | undefined>;
+/**
+ * Get all site settings
+ *
+ * Returns all configured settings. Unset values are undefined.
+ * Media references (logo/favicon) are resolved to include URLs.
+ *
+ * @example
+ * ```ts
+ * import { getSiteSettings } from "dineway";
+ *
+ * const settings = await getSiteSettings();
+ * console.log(settings.title); // "My Site"
+ * console.log(settings.logo?.url); // "/_dineway/api/media/file/abc123"
+ * ```
+ */
+declare function getSiteSettings(): Promise<Partial<SiteSettings>>;
+/**
+ * Set site settings (internal function used by admin API)
+ *
+ * Merges provided settings with existing ones. Only provided fields are updated.
+ * Media references should include just the mediaId; URLs are resolved on read.
+ *
+ * @param settings - Partial settings object with values to update
+ * @param db - Kysely database instance
+ * @returns Promise that resolves when settings are saved
+ *
+ * @internal
+ *
+ * @example
+ * ```ts
+ * // Update multiple settings at once
+ * await setSiteSettings({
+ *   title: "My Site",
+ *   tagline: "Welcome",
+ *   logo: { mediaId: "med_123", alt: "Logo" }
+ * }, db);
+ * ```
+ */
+declare function setSiteSettings(settings: Partial<SiteSettings>, db: Kysely<Database>): Promise<void>;
+/**
+ * Get a single plugin setting by key.
+ *
+ * Plugin settings are stored in the options table under
+ * `plugin:<pluginId>:settings:<key>`.
+ */
+declare function getPluginSetting<T = unknown>(pluginId: string, key: string): Promise<T | undefined>;
+/**
+ * Get all persisted plugin settings for a plugin.
+ *
+ * Defaults declared in `admin.settingsSchema` are not materialized
+ * automatically; callers should apply their own fallback defaults.
+ */
+declare function getPluginSettings(pluginId: string): Promise<Record<string, unknown>>;
+//#endregion
+//#region src/comments/query.d.ts
+interface GetCommentsOptions {
+  collection: string;
+  contentId: string;
+  threaded?: boolean;
+}
+interface GetCommentsResult {
+  items: PublicComment[];
+  total: number;
+}
+/**
+ * Get approved comments for a content item.
+ *
+ * @example
+ * ```ts
+ * import { getComments } from "dineway";
+ *
+ * const { items, total } = await getComments({
+ *   collection: "posts",
+ *   contentId: post.id,
+ *   threaded: true,
+ * });
+ * ```
+ */
+declare function getComments(options: GetCommentsOptions): Promise<GetCommentsResult>;
+/**
+ * Get the count of approved comments for a content item.
+ *
+ * @example
+ * ```ts
+ * import { getCommentCount } from "dineway";
+ *
+ * const count = await getCommentCount("posts", post.id);
+ * ```
+ */
+declare function getCommentCount(collection: string, contentId: string): Promise<number>;
+//#endregion
+//#region src/menus/types.d.ts
+/**
+ * Menu item types
+ */
+type MenuItemType = string;
+/**
+ * Menu item as returned to templates (with resolved URL)
+ */
+interface MenuItem {
+  id: string;
+  label: string;
+  url: string;
+  target?: string;
+  titleAttr?: string;
+  cssClasses?: string;
+  children: MenuItem[];
+}
+/**
+ * Menu as returned to templates
+ */
+interface Menu {
+  id: string;
+  name: string;
+  label: string;
+  items: MenuItem[];
+}
+/**
+ * Input for creating a menu item
+ */
+interface CreateMenuItemInput {
+  type: MenuItemType;
+  label: string;
+  referenceCollection?: string;
+  referenceId?: string;
+  customUrl?: string;
+  target?: string;
+  titleAttr?: string;
+  cssClasses?: string;
+  parentId?: string;
+  sortOrder?: number;
+}
+/**
+ * Input for updating a menu item
+ */
+interface UpdateMenuItemInput {
+  label?: string;
+  customUrl?: string;
+  target?: string;
+  titleAttr?: string;
+  cssClasses?: string;
+  parentId?: string | null;
+  sortOrder?: number;
+}
+/**
+ * Input for creating a menu
+ */
+interface CreateMenuInput {
+  name: string;
+  label: string;
+}
+/**
+ * Input for updating a menu
+ */
+interface UpdateMenuInput {
+  label?: string;
+}
+/**
+ * Input for reordering menu items
+ */
+interface ReorderMenuItemsInput {
+  items: Array<{
+    id: string;
+    parentId: string | null;
+    sortOrder: number;
+  }>;
+}
+//#endregion
+//#region src/menus/index.d.ts
+/**
+ * Get menu by name with resolved URLs
+ *
+ * @example
+ * ```ts
+ * import { getMenu } from "dineway";
+ *
+ * const menu = await getMenu("primary");
+ * if (menu) {
+ *   console.log(menu.items); // Array of MenuItem with resolved URLs
+ * }
+ * ```
+ */
+declare function getMenu(name: string): Promise<Menu | null>;
+/**
+ * Get all menus (without items - for admin list)
+ *
+ * @example
+ * ```ts
+ * import { getMenus } from "dineway";
+ *
+ * const menus = await getMenus();
+ * console.log(menus); // [{ id, name, label }]
+ * ```
+ */
+declare function getMenus(): Promise<Array<{
+  id: string;
+  name: string;
+  label: string;
+}>>;
+//#endregion
+//#region src/taxonomies/types.d.ts
+/**
+ * Taxonomy types for Dineway Agentic Web builder
+ */
+/**
+ * Taxonomy definition - describes a taxonomy like "category" or "tag"
+ */
+interface TaxonomyDef {
+  id: string;
+  name: string;
+  label: string;
+  labelSingular?: string;
+  hierarchical: boolean;
+  collections: string[];
+}
+/**
+ * Taxonomy term - a specific term within a taxonomy (e.g., "News" in "category")
+ */
+interface TaxonomyTerm {
+  id: string;
+  name: string;
+  slug: string;
+  label: string;
+  parentId?: string;
+  description?: string;
+  children: TaxonomyTerm[];
+  count?: number;
+}
+/**
+ * Flat version for DB row
+ */
+interface TaxonomyTermRow {
+  id: string;
+  name: string;
+  slug: string;
+  label: string;
+  parent_id: string | null;
+  data: string | null;
+}
+/**
+ * Input for creating a term
+ */
+interface CreateTermInput {
+  slug: string;
+  label: string;
+  parentId?: string;
+  description?: string;
+}
+/**
+ * Input for updating a term
+ */
+interface UpdateTermInput {
+  slug?: string;
+  label?: string;
+  parentId?: string | null;
+  description?: string;
+}
+//#endregion
+//#region src/taxonomies/index.d.ts
+/**
+ * Get all taxonomy definitions
+ */
+declare function getTaxonomyDefs(): Promise<TaxonomyDef[]>;
+/**
+ * Get a single taxonomy definition by name
+ */
+declare function getTaxonomyDef(name: string): Promise<TaxonomyDef | null>;
+/**
+ * Get all terms for a taxonomy (as tree for hierarchical, flat for tags)
+ */
+declare function getTaxonomyTerms(taxonomyName: string): Promise<TaxonomyTerm[]>;
+/**
+ * Get a single term by taxonomy and slug
+ */
+declare function getTerm(taxonomyName: string, slug: string): Promise<TaxonomyTerm | null>;
+/**
+ * Get terms assigned to an entry
+ */
+declare function getEntryTerms(collection: string, entryId: string, taxonomyName?: string): Promise<TaxonomyTerm[]>;
+/**
+ * Get terms for multiple entries in a single query (batched API)
+ *
+ * This is more efficient than calling getEntryTerms for each entry
+ * when you need terms for a list of entries.
+ *
+ * @param collection - The collection type (e.g., "posts")
+ * @param entryIds - Array of entry IDs
+ * @param taxonomyName - The taxonomy name (e.g., "categories")
+ * @returns Map from entry ID to array of terms
+ */
+declare function getTermsForEntries(collection: string, entryIds: string[], taxonomyName: string): Promise<Map<string, TaxonomyTerm[]>>;
+/**
+ * Get entries by term (wraps getDinewayCollection)
+ */
+declare function getEntriesByTerm(collection: string, taxonomyName: string, termSlug: string): Promise<Array<{
+  id: string;
+  data: Record<string, unknown>;
+}>>;
+//#endregion
+//#region src/widgets/types.d.ts
+type WidgetType = "content" | "menu" | "component";
+interface Widget {
+  id: string;
+  type: WidgetType;
+  title?: string;
+  content?: PortableTextBlock[];
+  menuName?: string;
+  componentId?: string;
+  componentProps?: Record<string, unknown>;
+}
+interface WidgetArea {
+  id: string;
+  name: string;
+  label: string;
+  description?: string;
+  widgets: Widget[];
+}
+interface WidgetComponentDef {
+  id: string;
+  label: string;
+  description?: string;
+  props: Record<string, PropDef>;
+}
+interface PropDef {
+  type: "string" | "number" | "boolean" | "select";
+  label: string;
+  default?: unknown;
+  options?: Array<{
+    value: string;
+    label: string;
+  }>;
+}
+interface CreateWidgetAreaInput {
+  name: string;
+  label: string;
+  description?: string;
+}
+interface CreateWidgetInput {
+  type: WidgetType;
+  title?: string;
+  content?: PortableTextBlock[];
+  menuName?: string;
+  componentId?: string;
+  componentProps?: Record<string, unknown>;
+}
+interface UpdateWidgetInput extends Partial<CreateWidgetInput> {}
+interface ReorderWidgetsInput {
+  widgetIds: string[];
+}
+//#endregion
+//#region src/widgets/index.d.ts
+/**
+ * Get a widget area by name, with all its widgets
+ */
+declare function getWidgetArea(name: string): Promise<WidgetArea | null>;
+/**
+ * Get all widget areas with their widgets
+ */
+declare function getWidgetAreas(): Promise<WidgetArea[]>;
+/**
+ * Get available widget components (for admin UI)
+ */
+declare function getWidgetComponents(): WidgetComponentDef[];
+//#endregion
+export { TranslationSummary as $, MenuItem as A, getPluginSettings as B, TaxonomyTermRow as C, CreateMenuInput as D, getMenus as E, GetCommentsOptions as F, CollectionFilter as G, getSiteSettings as H, GetCommentsResult as I, DinewayCollections as J, CollectionResult as K, getCommentCount as L, ReorderMenuItemsInput as M, UpdateMenuInput as N, CreateMenuItemInput as O, UpdateMenuItemInput as P, ResolvePathResult as Q, getComments as R, TaxonomyTerm as S, PublicComment as St, getMenu as T, setSiteSettings as U, getSiteSetting as V, CacheHint as W, EntryResult as X, EditFieldMeta as Y, InferCollectionData as Z, getTaxonomyTerms as _, FieldDefinition as _t, CreateWidgetInput as a, resolveDinewayPath as at, CreateTermInput as b, ImageValue as bt, UpdateWidgetInput as c, FieldAnnotation as ct, WidgetComponentDef as d, isSafeHref as dt, TranslationsResult as et, WidgetType as f, sanitizeHref as ft, getTaxonomyDefs as g, image as gt, getTaxonomyDef as h, reference as ht, CreateWidgetAreaInput as i, getTranslations as it, MenuItemType as j, Menu as k, Widget as l, createEditable as lt, getEntryTerms as m, portableText as mt, getWidgetAreas as n, getDinewayEntry as nt, PropDef as o, CMSAnnotation as ot, getEntriesByTerm as p, getCollectionInfo as pt, ContentEntry as q, getWidgetComponents as r, getEditMeta as rt, ReorderWidgetsInput as s, EditProxy as st, getWidgetArea as t, getDinewayCollection as tt, WidgetArea as u, createNoop as ut, getTerm as v, FieldUIHints as vt, UpdateTermInput as w, TaxonomyDef as x, PortableTextBlock as xt, getTermsForEntries as y, FileValue as yt, getPluginSetting as z };